剑指Offer19-0926

从头到尾打印链表

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

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        list=[]
        if listNode == None:
            return []
        return self.printListFromTailToHead(listNode.next)+[listNode.val]

重建二叉树

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

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if not pre or not tin :
            return None
        root=TreeNode(pre.pop(0))
        index=tin.index(root.val)
        root.left=self.reConstructBinaryTree(pre,tin[:index])
        root.right=self.reConstructBinaryTree(pre,tin[index+1:])
        return root

递归调用，注意：

• 1，递归调用的形式是先左子树然后右子树
• 2，pre对象可改变

旋转数组的最小数字

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

#循环迭代 查找最小O（n）复杂度
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray) == 0:
            return 0
        if len(rotateArray) == 1:
            return rotateArray[0]
        for i in range(len(rotateArray)):
            if i == len(rotateArray)-1:
                break
            if rotateArray[i] > rotateArray[i+1]:
                return rotateArray[i+1]
        return rotateArray[0]

法二：二分查找法

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # 可以使用min()函数， 但是在不适用min函数的情况下，思路应该是二分查找
        # 下面使用 递归实现2分查找，其中递归的时候必须使用return！！！ 不然会返回none
        # write code here 
        start = 0
        end = len(rotateArray) - 1
        mid = int((start + end) / 2)
        if len(rotateArray) == 2:
            if rotateArray[0]>rotateArray[1]:
                return rotateArray[1]
            else:
                return rotateArray[0]
        elif rotateArray[mid] > rotateArray[end]:
            return self.minNumberInRotateArray(rotateArray[mid:end + 1])
        elif rotateArray[mid] < rotateArray[start]:
            return self.minNumberInRotateArray(rotateArray[start:mid + 1])

斐波那契数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39

#无脑递归，复杂度过大
class Solution:
    def Fibonacci(self, n):
        # write code here
        if n == 0:
            return 0
        if n == 1:
            return 1
        return self.Fibonacci(n-1)+self.Fibonacci(n-2)

# 用列表将中间结果保存下来
class Solution:
    def Fibonacci(self, n):
        # write code here
        res=[0,1]
        while len(res)<=n:
            res.append(res[-1]+res[-2])
        return res[n]

跳台阶

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

• 可以将问题转化为动态规划问题
• 然后变成菲波那切数列问题
• f(N)=f(N-1)+f(N-2) (f(N-1)为跳一阶，f(N-2)为跳两阶）)

class Solution:
    def jumpFloor(self, number):
        # write code here
        bp=[1,2]
        while len(bp)<=number:
            bp.append(bp[-1]+bp[-2])
        return bp[number-1]

变态跳台阶

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

• f(1)=1 f(2)=2
• f(N)=f(N-1)+f(N-2)+···+f(1)+1 n>2
• 注意要加上 1

class Solution:
    def jumpFloorII(self, number):
        # write code here
        bp=[1,2]
        while len(bp)<=number:
            bp.append(sum(bp)+1)
        return bp[number-1]

可进一步简化为2**（n-1）

矩形覆盖

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

class Solution:
    def rectCover(self, number):
        # write code here
        bp=[0,1,2]
        while len(bp) <= number:
            bp.append(bp[-1]+bp[-2])
        return bp[number]

类似于跳台阶问题，动态规划解决即可