[持久更新] 剑指offer题目Python做题记录

第一题

　　题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

　　思路：先快速定位到该数在哪一行，然后再迅速定位具体位置。

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        row = 0
        col = len(array[0]) - 1 
        while col >= 0 and row < len(array):
            if target == array[row][col]:
                return True
            elif target > array[row][col]:
                row = row + 1
            else:
                col = col - 1
        return False

第二题

　　题目：请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

　　思路：使用字符串的replace方法即可。

# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        s = s.replace(' ','%20')
        return s

第三题

　　题目：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

　　思路：先用append方法讲链表储存，然后使用reverse方法颠倒列表。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        out = []
        while listNode:
            out.append(listNode.val)
            listNode = listNode.next
        out.reverse()
        return out

第四题

　　题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

　　思路：前序遍历是由根开始，从左树到右数遍历。中序遍历是由左树开始，到根节点然后到右树。后序与中序相反。只考虑前序和中序，根节点在前序的首位，在中序的左树与右树的分割点。通过index方法，可以得出左树与右树的长度，然后通过递归重建二叉树。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre) == 0:
            return None
        elif len(pre) == 1:
            return TreeNode(pre[0])
        else:
            tree = TreeNode(pre[0])
            tree.left = self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
            tree.right = self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
        return tree

第五题 

　　题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

　　思路：一个栈来实现存储，一个栈来实现先入先出。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.save = []
    def push(self, node):
        # write code here
        self.save.append(node)
    def pop(self):
        # write code here
        out = self.save[-1]
        del self.save[-1]
        return out

第六题

　　题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

　　思路：直接用min()方法好像也能通过，不然用循环也可完成目标。

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray) == 0:
            return 
        else:
            while len(rotateArray) > 1:
                if rotateArray[0] < rotateArray[-1]:
                    return rotateArray[0]
                else:
                    rotateArray[0] = rotateArray[-1]
                    del rotateArray[-1]
            else:
                return rotateArray[0]

第七题

　　题目：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

　　思路：斐波那契数列就是下一个数是前两个数之和，开头两个分别为1，1。

# -*- coding:utf-8 -*-
class Solution:
    def Fibonacci(self, n):
        # write code here
        if n == 0:
            return 0
        elif n >0 and n<=2:
            return 1
        else:
            n_1,n_2 = 1,1
            for i in range(n-2):
                cun = n_2
                n_2 = n_1 + n_2
                n_1 = cun
            return n_2

第八题

　　题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

　　思路：在大于2以后，可以考虑最后一步有两种可能，一种是跳一步，一种是跳两步，也就是说，跳n个台阶的方法与跳n-1与n-2个台阶的和的方法数相同。本题就与斐波那契数列相同。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloor(self, number):
        # write code here
        n_0,n_1,n_2 = 0,1,0
        for i in range(number):
            n_2 = n_0 + n_1
            n_0 = n_1
            n_1 = n_2
        return n_2

第九题 

　　题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

　　思路：条1~2级就是斐波那契数列，跳的越多，加入之前的项越多，跳n级即前n项之和，就有f(n)=f(n-1)+......+f(1)。f(n-1) = f(n-2)+......+f(1)。所以归纳出，f(n)=2^(n-1)。这里可以用**方法。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloorII(self, number):
        # write code here
        out = 2**(number-1)
        return out

 第十题

　　题目：我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

　　思路：这个依然是斐波那契数列问题变种，2*4的矩形就是2*3的方法数加上一块2*2的方法数。

# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
        # write code here
        n_0,n_1,n_2 = 0,1,0
        for i in range(number):
            n_2 = n_0 + n_1
            n_0 = n_1
            n_1 = n_2
        return n_2

第十一题 

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

　　思路：想不到什么好办法，就准备直接将数转换为二进制的string型，这里负数-2147483648的补码是1000 0000 0000 0000 0000 0000 0000与其他负数不同。

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        if n >= 0:
            flag = False
        elif n == -2147483648:
            return 1
        else:
            flag = True
            n = 2**31 - 1 + n
        num = ''
        while n>0:
            if n%2 == 1:
                num = '1' + num
            else:
                num = '0' + num
            n = int(n/2)
        if flag:
            num = num.zfill(31)
            new = list(num)
            for i in range(31):
                if new[30 - i] == '0':
                    new[30 - i] = '1'
                    break
                else:
                    new[30 - i] = '0'
            num = ''.join(new)
            num = '1' + num
        t = 0
        for i in num:
            if i == '1':
                t = t + 1
        return t

第十二题

　　题目：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

　　思路：在Python中没有数字类型的严格定义，全都为C语言中double型编程而来，所以这里不需要特别注意，直接求解就可。

# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        # write code here
        n = base**exponent
        return n

第十三题 

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

　　思路：直接可以循环整个数组，分别找出奇数和偶数列表后合并。

# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        # write code here
        odd,even = [],[]
        for i in array:
            if i%2 == 0:
                even.append(i)
            else:
                odd.append(i)
        return odd + even

第十四题 

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

　　思路：这里输入的是一个链表，可以用next方法读出链表的内容。可以首先得到所有链表的长度，然后利用该长度计算需要next的次数，得到所需要的节点。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        out = head
        num = 0
        while head:
            num += 1
            head = head.next
        if k > num:
            return None
        else:
            for i in range(num-k):
                out = out.next
            return out

第十五题 

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

　　思路：这里是要反转链表，可以首先得到将旧链表所有的值，然后依次赋给新链表的next来完成。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        nHead = None
        plist = []
        while pHead:
            plist.append(pHead)
            pHead = pHead.next
        for i in plist:
            mHead = i
            oHead = nHead
            nHead = mHead
            nHead.next = oHead
        return nHead

第十六题 

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

　　思路：可以参考上一题，将两个链表中所有值取出后，依次赋给新的链表。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        nHead = None
        plist = []
        while pHead1 or pHead2:
            if pHead1 != None and pHead2 != None:
                plist.append(pHead1)
                plist.append(pHead2)
                pHead1 = pHead1.next
                pHead2 = pHead2.next
            elif pHead1 != None and pHead2 == None:
                plist.append(pHead1)
                pHead1 = pHead1.next
            elif pHead1 == None and pHead2 != None:
                plist.append(pHead2)
                pHead2 = pHead2.next
        plist.reverse()
        for i in plist:
            mHead = i
            oHead = nHead
            nHead = mHead
            nHead.next = oHead
        return nHead

第十七题 

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

　　思路：首先找出与B树根节点相同的，然后分别判断下一层是否相同。分别判断根节点，左大树，右大树。这道题有点懵。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        flag = False
        if pRoot1 == None or pRoot2 == None:
            return False
        if pRoot1.val == pRoot2.val:
            #判断是否在树根
            flag = Solution.judge(self, pRoot1, pRoot2)
        if not flag:
            #判断是否在左树
            flag = Solution.HasSubtree(self, pRoot1.left, pRoot2)
        if not flag:
            #判断是否在右树
            flag = Solution.HasSubtree(self, pRoot1.right, pRoot2)
        return flag
    
    def judge(self, pRoot1, pRoot2):
        if pRoot2 == None:
            return True
        elif pRoot1 == None:
            return False
        elif pRoot1.val != pRoot2.val:
            return False
        else:
            #递归判断
            right_flag = Solution.judge(self, pRoot1.right, pRoot2.right)
            left_flag = Solution.judge(self, pRoot1.left, pRoot2.left)
            return right_flag and left_flag

第十八题 

　　题目：操作给定的二叉树，将其变换为源二叉树的镜像。

　　思路：不断循环调用，左树赋值给右树，右树赋值给左树

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if root == None:
            return None
        root.left,root.right = root.right,root.left
        if root.left:
            self.Mirror(root.left)
        if root.right:
            self.Mirror(root.right)
        return root

第十九题

　　题目：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

　　思路：每个周期会进行四步，顶行打印，右列打印，底行打印，左列打印。循环即可。

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        row = len(matrix)
        col = len(matrix[0])
        left,right = 0,col
        high,down = 0,row
        res = []
        while left<right and high<down:
            # h_line
            for i in range(left,right):
                res.append(matrix[high][i])
            high = high + 1
            if high == down:
                break
            # r_line
            for i in range(high,down):
                res.append(matrix[i][right-1])
            right = right - 1
            if right == left:
                break
            for i in range(right-1,left-1,-1):
                res.append(matrix[down-1][i])
            down = down - 1
            if high == down:
                break
            for i in range(down-1,high-1,-1):
                res.append(matrix[i][left])
            left = left + 1
            if right == left:
                break
        return res

第二十题

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

　　思路：在第五题基础上增加min操作。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.save = []
    def push(self, node):
        # write code here
        self.save.append(node)
    def pop(self):
        # write code here
        out = self.save[-1]
        del self.save[-1]
        return out
    def top(self):
        # write code here
        out = self.save[0]
        return out
    def min(self):
        # write code here
        return min(self.save)

第二十一题

　　题目：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

　　思路：逐个将压入顺序的序列压入到列表中，分别与弹出第一位比较，相同则分别弹出后继续比较，直至压完所有的压入栈，最后看列表是否完全弹空。

# -*- coding:utf-8 -*-
class Solution:
    def IsPopOrder(self, pushV, popV):
        # write code here
        if len(pushV) != len(popV):
            return False
        else:
            pushN = []
            for i in pushV:
                pushN.append(i)
                while pushN and pushN[-1] == popV[0]:
                    pushN.pop()
                    del popV[0]
            return len(pushN) == 0

第二十二题

　　题目：从上往下打印出二叉树的每个节点，同层节点从左至右打印。

　　思路：建立一个容器，依次将树的节点从左至右排队插入，依次存入要打印的列表中。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        tree = []
        if root:
            temp = [root]
            while len(temp):
                x = temp.pop(0)
                tree.append(x.val)
                if x.left:
                    temp.append(x.left)
                if x.right:
                    temp.append(x.right)
        return tree

第二十三题

 　　题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

　　思路：后序遍历二叉树，根节点在最后一位，比它小的一齐在最前面是左树，比它大的一齐在后面是右树。

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        size = len(sequence)
        if size == 1:
            return True
        elif size == 0:
            return False
        left,right = [],[]
        flag_l,flag_r = True,True
        i = 0
        while sequence[i]<sequence[-1] and i <size-1:
            left.append(sequence[i])
            i += 1
        right = sequence[i:size-1]
        if right:
            for j in right:
                if j <= sequence[-1]:
                    return False
            else:
                flag_r = Solution.VerifySquenceOfBST(self, right)
        if left:
            flag_l = Solution.VerifySquenceOfBST(self, left)
        return flag_l and flag_r

第二十四题

　　题目：输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

　　思路：前序遍历，找到同时满足左右子树为空，根节点与值相同的情况。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表，内部每个列表表示找到的路径
    def FindPath(self, root, expectNumber):
        # write code here
        if not root:
            return []
        if not root.left and not root.right and expectNumber == root.val:
            return [[root.val]]
        res = []
        left = self.FindPath(root.left,expectNumber-root.val)
        right = self.FindPath(root.right,expectNumber-root.val)
        for i in left+right:
            res.append([root.val]+i)
        return res