剑指offer刷题(11-20) python

在线做题链接 牛客网

面试题11.二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

# 使用位移和与运算，例如 1001&1 = 1 ，右移一位 100&1=0，以此类推
class Solution:
    def NumberOf1(self, n):
        # write code here
        num,i=0,0
        while i<32:
            if (n>>i)&1:
                num+=1
            i+=1
        return num

面试题12.数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0

# 题目意思很明显是求base的exponent次方，而python中的平方可以用
# base**exponent表示,** 底层的源码是快速幂，但是题目原意是手撸快速幂
# 要考虑幂为负数的情况
class Solution:
    def Power(self, base, exponent):
        if not base:
            return 0
        if not exponent:
            return 1
        s = base
        summ = 1
        x = abs(exponent)
        while x:
            if x % 2 == 1:
                summ = summ * s
            x=x//2
            s = s*s
        return summ if exponent>0 else 1/(summ)

面试题13.调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

# 定义两个列表，然后遍历原列表，奇数偶数分开加入两个列表，然后两个列表进行拼接
class Solution:
    def reOrderArray(self, array):
        a,b=[],[]
        for i in array:
            if i&1:
                a.append(i)
            else:
                b.append(i)
        return a+b

面试题14.链表中倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

方法: 大家都知道链表不易查询，这道题用快慢指针
一个指针先走k个点，然后两个指针一块走，当第一个走到末尾，
第二个就是倒数第k个节点，需要注意的是判断链表是否有k个节点

# 快慢指针还可以用来求 环，中位数
class Solution:
    def FindKthToTail(self, head, k):
        fast,slow = head,head
        for i in range(k):
            if fast:
                fast = fast.next
            else:
                return None  # 链表没有k个
        while fast:
            fast=fast.next
            slow=slow.next
        return slow

面试题15.反转链表

输入一个链表，反转链表后，输出新链表的表头。

class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        if pHead:
            end = ListNode(pHead.val)
            while pHead.next != None:
                pHead = pHead.next
                start = ListNode(pHead.val)
                start.next = end
                end = start
            return end
        return pHead

面试题16.合并两个排序的链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

# 随便定义一个头结点，值不重要，然后遍历两个链表即可
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        l = ListNode(90)
        start = l
        while pHead1 and pHead2:
            if pHead1.val>pHead2.val:
                l.next = ListNode(pHead2.val)
                x = pHead1
                pHead2 = pHead2.next
            else:
                l.next = ListNode(pHead1.val)
                x = pHead2
                pHead1 = pHead1.next
            l = l.next
        if pHead1:
            l.next = pHead1
        if pHead2:
            l.next = pHead2
        return start.next

面试题17.树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

# 求出两棵树的前序遍历，用字符串拼接，中间不留空，判断b是否属于a即可
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if pRoot2 and pRoot1:
            def dfs(x):
                if x:
                    return str(x.val)+dfs(x.left)+dfs(x.right)
                return ''
            s1 = dfs(pRoot1)
            s2 = dfs(pRoot2)
            return s2 in s1
        return False

面试题18.二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
    8
    / \
   6 10
   / \ / \
  5 7 9 11
镜像二叉树
    8
    / \
   10 6
   / \ / \
  11 9 7 5

递归

class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if root != None:
            root.left,root.right = root.right,root.left
            self.Mirror(root.left)
            self.Mirror(root.right)

面试题19.顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

# 简单模拟，思路要清晰，上下左右找，全部找到后break
class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        l = []
        h = len(matrix)
        if not h:
            return l
        w = len(matrix[0])
        summ = w*h
        h0,w0=0,0
        while len(l)<summ:
            for i in range(w0,w):   # 第一行
                l.append(matrix[h0][i])
            if len(l)>=summ:
                break
            for i in range(h0+1,h):  # 右边列
                l.append(matrix[i][w-1])
            if len(l)>=summ:
                break
            for i in range(w-2,w0-1,-1): # 最后一行
                l.append(matrix[h-1][i])
            if len(l)>=summ:
                break
            for i in range(h-2,h0,-1): # 左表行
                l.append(matrix[i][w0])
            h0+=1
            w0+=1
            h-=1
            w-=1
        return l

20.包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））

思路 :列表中每次添加时存放一个元组，元组的第一个值是当前值，第二个值为当前的最小值，然后每次添加时取当前最小值与当前添加值作比较

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.s = []
    def push(self, node):
        minx = self.min()
        if node<minx or not minx:
            minx = node
        self.s.append((node,minx))
        # write code here
    def pop(self):
        if not len(self.s):
            return None
        return self.s.pop()
        # write code here
    def top(self):
        if not len(self.s):
            return None
        return self.s[-1][0]
        # write code here
    def min(self):
        if not len(self.s):
            return None
        return self.s[-1][1]
        # write code here