剑指OFFER（持续更新中...)

基本用python,涉及到栈，链表，二叉树，数组，字符串

python中的类中属性元素加self.和不加self.的区别：

如果不加self，表示是类的一个属性（可以通过“类名.变量名”的方式引用），加了表示是类的实例的一个属性（可以通过“实例名.变量名”的方式引用）。

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

简单：遍历操作

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        row=len(array)
        col=len(array[0])
        for i in range(row):
            for j in range(col):
                if array[i][j]==target:
                    return True
        return False

高效：矩阵是有序的，从左下角元素来看，往右数字递增，往上数字递减。因此从左下角开始找，如果target比左下角元素大，向右移，否则，向左移。

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

# -*- coding:utf-8-*-
classSolution:
    # s 源字符串
    def replaceSpace(self, s):
       return s.replace(' ','%20') 

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

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
# 1.先遍历链表元素到栈
# 2.栈再弹出
class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        lst,lst_bak = [],[]
        if not listNode:
            return lst
        while listNode:
            lst.append(listNode.val)
            listNode = listNode.next
        while lst:
            lst_bak.append(lst.pop())
        return lst_bak

 注意：pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

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

# -*- 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 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

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

入队：将元素进栈1

出队：判断栈2是否为空，如果为空，则将栈1中所有元素pop，并push进栈B，栈B出栈；如果不为空，栈2直接出栈。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        # return xx
        if len(self.stack2) > 0:
            return self.stack2.pop()
        while self.stack1:
            self.stack2.append(self.stack1.pop())
        if len(self.stack2) > 0:
            return self.stack2.pop()

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

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        return min(rotateArray)

 注：这个题可能有问题了。。

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

# -*- coding:utf-8 -*-
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]

大话数据结构102页。斐波那契数列：0，1，1，2，3，5，8..... F(n)=F(n-1)+F(n-2)

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

设跳第n级台阶的跳法种数为f(n)，f(1) = 1, f(2) = 2, f(3) = 3, f(4) = 5，  可以总结出f(n) = f(n-1) + f(n-2)的规律

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

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

（1）假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1)；假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)；假定第一次跳的是3阶，那么剩下的是n-3个台阶，跳法是f(n-3)......假定第一次跳的是n-1阶，那么剩下的是1个台阶，跳法是f(1)； 假定第一次跳的是n阶，那么剩b下的是0个台阶，跳法是1种；

（2）总跳法为: f(n) = 1+f(n-1) + f(n-2)+....+f(1)  （第一个1是跳n阶只有一种方法）

（3）根据（2）可以得出有一阶的时候 f(1) = 1 ；有两阶的时候可以有 f(2) = 1+f(1)=2；有三阶的时候可以有 f(3) = 1+f(2)+f(1)=4...依次内推，有n阶时f(n)=2^(n-1)。

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

10.我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？递推关系式为f(n) = f(n-1) + f(n-2)， (n > 2)

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

11.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
解法：如果n大于0，直接计算即可，如果n小于0，计算2的32次方加上n的结果中1的个数。记住吧，我也不明白

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        return bin(n).replace("0b","").count("1") if n>=0 else bin(2**32+n).replace("0b","").count("1")

注：bin() 返回一个整数 int 或者长整数 long int 的二进制表示。>bin(10)>> '0b1010'

1. 正数原码就是其二进制。
2. 负数的原码就是其二进制，并将最高位作为符号位设为1。
   eg: -1 原码为：1000 0001
3. 负数进行运算时用补码表示：负数补码 = 负数原码不考虑最高符号位的原码的反码 + 1
   eg： -1 的补码为：1111 1110（反码） +1 = 1111 1111

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

# -*- coding:utf-8 -*-
class Solution:
    def Power(self, bas