剑指Offer 67题总结（python版（持续更新11-20））

11、二进制中1的个数

思路：对进制不熟悉，参考网上大神的

    def NumberOf1(self, n):
        # write code here
        count = 0
        while n&0xffffffff != 0:
            count += 1
            n = n & (n-1)
        return count

12、数值的整数次方

思路：

    def Power(self, base, exponent):
        # write code here
        if base == 0:
            return 0
        elif base==1 or exponent==0:
            return 1
        elif exponent ==1:
            return base
        res = 1
        for i in range(abs(exponent)):
            res *= base
        if exponent < 0:
            res = 1/res
        return res

13、调整数组顺序使奇数位于偶数前面

思路：用两个空数组，一个用于存储奇数，一个用于存储偶数，最后合并两个数组。

    def reOrderArray(self, array):
        # write code here
        a=[]
        b=[]
        for i in range(len(array)):
            if array[i]%2!=0:
                a.append(array[i])
            else:
                b.append(array[i])
        return a+b

14、链表中倒数第k个结点

思路：使用两个节点，使他们始终保持k个结点的距离。

    def FindKthToTail(self, head, k):
        # write code here
        if head==None or k<=0:
            return None
        p1 = head
        p2 = head
        for i in range(k-1):
            if p1.next == None:
                return None
            else:
                p1=p1.next
        while p1.next!=None:
            p1=p1.next
            p2=p2.next
        return p2

15、反转链表

思路:

    def ReverseList(self, pHead):
        # write code here
        if not pHead or not pHead.next:
            return pHead
        NewHead = self.ReverseList(pHead.next)
        pHead.next.next = pHead
        pHead.next = None
        return NewHead

16、合并两个排序的链表

思路:递归

    def Merge(self, pHead1, pHead2):
        # write code here
        if not pHead1:
            return pHead2
        if not pHead2:
            return pHead1
        if pHead1.val<=pHead2.val:
            pHead1.next=self.Merge(pHead1.next,pHead2)
            return pHead1
        else:
            pHead2.next=self.Merge(pHead1,pHead2.next)
            return pHead2

17、树的子结构

思路：

    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        def convert(p):
            if p:
                return str(p.val) +  convert(p.left) + convert(p.right)
            else:
                return ""
        return convert(pRoot2) in convert(pRoot1) if pRoot2 else False

18、二叉树的镜像

思路:递归

    def Mirror(self, root):
        # write code here
        if root:
            root.left, root.right = root.right, root.left
            self.Mirror(root.left)
            self.Mirror(root.right)

19、顺时针打印矩阵

思路:先取矩阵的第一行，接着将剩下作为新矩阵进行一个逆时针90度的翻转，接着获取第一行，直到矩阵为空。需要注意的点pop() 越界，翻转矩阵的时候相当于将列数据变成行数据，可以一列一列获取最后注意顺序。

    def printMatrix(self, matrix):
        # write code here
        result = []
        while(matrix):
            result += matrix.pop(0)
            if not matrix:
                break
            matrix = self.turn(matrix)
        return result
    def turn(self,matrix):
        num_r = len(matrix)
        num_c = len(matrix[0])
        newmat = []
        for i in range(num_c):
            newmat2 = []
            for j in range(num_r):
                newmat2.append(matrix[j][i])
            newmat.append(newmat2)
        newmat.reverse()
        return newmat

20、包含min函数的栈

    def __init__(self):
        self.stack = []
        self.min_stack = []
    def push(self, node):
        # write code here
        self.stack.append(node)
        if not self.min_stack or node <= self.min_stack[-1]:
            self.min_stack.append(node)
    def pop(self):
        # write code here
        if self.stack[-1] == self.min_stack[-1]:
            self.min_stack.pop()
        self.stack.pop()
    def top(self):
        # write code here
        return self.stack[-1]
    def min(self):
        # write code here
        return self.min_stack[-1]