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

循环实现，时间复杂度n

def Fibonacci(self, n):
        if n == 0:
            return 0
        if n == 1:
            return 1
        a = 1
        b = 0
        ret = 0
        for i in range(0, n-1):	#[0,n-1)
            ret = a + b
            b = a
            a = ret
        return ret

递归实现，时间复杂度2^n

def Fibonacci(self, n):
        if n == 0:
            return 0
        if n == 1:
            return 1
        if n > 1：
            num = self.Fibonacci(n-1) + self.Fibonacci(n-2)
            return num
1
2
3
4
5
6
7
8

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

a.假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1)
b.假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)
c.由a和b假设可以得出总跳法为: f(n) = f(n-1) + f(n-2)
d.然后通过实际的情况可以得出：只有一阶的时候 f(1) = 1，只有两阶的时候可以有 f(2) = 2
e.可以发现最终得出的是一个斐波那契数列

def jumpFloor(self, number):
        # write code here
        if number == 1:
            return 1
        a = 1
        b = 1
        for i in range(1, number):
            ret = a + b
            b = a
            a = ret
        return ret
1
2
3
4
5
6
7
8
9
10
11

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

思路1：每个台阶可以看作一块木板，让青蛙跳上去，n个台阶就有n块木板，最后一块木板是青蛙到达的位子，必须存在，其他 (n-1) 块木板可以任意选择是否存在，则每个木板有存在和不存在两种选择，(n-1) 块木板就有 [2^(n-1)] 种跳法，可以直接得到结果

思路2：因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级
跳1级，剩下n-1级，则剩下跳法是f(n-1)
跳2级，剩下n-2级，则剩下跳法是f(n-2)
跳n级，剩下n-2级，则剩下跳法是f(0)
所以f(n)=f(n-1)+f(n-2)+…+f(1)+f(0)
因为f(n-1)=f(n-2)+f(n-3)+…+f(1)+f(0)
所以f(n)=2*f(n-1)

def jumpFloorII(self, number):
        # write code here
        return pow(2,number-1)
1
2
3

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

从右上角的数开始找：
大于则向下，第一行的数无需对比
小于则向左，最后一列的数无需对比

def Find(self, target, array):
        # write code here
        rows = len(array)
        cols = len(array[0])
        if rows >0 and cols >0:
            i=0
            j= cols - 1
            while i < rows and j >= 0:
                value = array[i][j]
                if value == target:
                    return True
                elif value > target:
                    j -= 1
                else:
                    i += 1
        return False
1415
16

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

-- coding:utf-8 --

class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        #方法一  一次遍历  时间 O(n)  空间O(n)
        result = ''
        for i in s:
            if i == ' ':
                result += '%20'
            else:
                result += i
        return result
 
        # 方法二  使用内置函数   
        return s.replace(' ','%20')
1415

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

第一个栈临时保存插入的数据，当调用弹出函数的时候，如果stack2不为空则直接弹出；为空则把stack1中的数据全部弹出放到stack2中。这样不会存在冲突，而且由于stack2保存的是以前的老数据，弹出一定都符合队列的规律

class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        self.stack1.append(node)
    def pop(self):
        if self.stack2:
            return self.stack2.pop()
        else:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop()

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

旋转后的数组先递增，然后突然断层，让后又递增，所以，只要找到数组突然变小的那个数字即可。
二分查找法：如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。

但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # 优化后的遍历
        if rotateArray is None:
            return None
        temp = rotateArray[0]
        for i in range(len(rotateArray) - 1):
            if rotateArray[i] > rotateArray[i+1]:
                temp = rotateArray[i+1]
                break
        return temp
       
        # binarySearch O(lg(n))
        if not rotateArray:
            return 0
        left = 0
        right = len(rotateArray) - 1
        while left <= right:
            mid = (left + right) >> 1 # (left +right)/2
            if rotateArray[mid] < rotateArray[mid-1]:
                return rotateArray[mid]
            elif rotateArray[mid] < rotateArray[right]:
                right = mid - 1
            else:
                left = mid + 1
        return 0
1415
16
17
18
19
20
21
22
23
24
25
26

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

数组里的任意相邻两个数必须是{奇数，偶数}的形式，任何出现{偶数，奇数}的形式，都要把两个数交换位置。套用冒泡排序的思想，只需要将原来冒泡排序的判断条件从比较两个数的大小改为判断相邻两个数是否为{奇数，偶数}的形式即可。

def reOrderArray(self, array):
        # 时间复杂度O(n)，空间复杂度O(n)
        ret = []
        for i in array:
            if i % 2 == 1:
                ret.append(i)
        for i in array:
            if i % 2 == 0:
                ret.append(i)
        return ret
        # 简化代码
        odd,even = [],[]
        for i in array:
            odd.append(i) if i % 2 == 1 else even.append(i)
        return odd + even
		
		# 冒泡排序法，时间复杂度O(n^2)
        arrayLen = len(array)
        for i in range(arrayLen):
            for j in range(arrayLen - i - 1):
                if array[j] % 2 == 0 and array[j + 1] % 2 == 1:
                    array[j + 1],array[j] = array[j],array[j + 1]
        return array
1415
16
17
18
19
20
21
22
23

包含min函数的栈
定义栈的数python基础教程据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

def __init__(self):
        self.stack = []
        self.min_stack = []
    def push(self, node):
        self.stack.append(node)
        #如果min_stack为空，或者当前结点值小于等于栈最后的那个值
        if not self.min_stack or node <= self.min_stack[-1]:
            self.min_stack.append(node)
    def pop(self):
        if self.stack[-1] == self.min_stack[-1]:
            self.min_stack.pop()
        self.stack.pop()
    def top(self):
        return self.stack[-1]
    def min(self):
        return self.min_stack[-1]
1415
16

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

pushV压入栈，循环判断压入栈的顶部和当前弹出栈的顶部数据是否相等，相等则弹出，最终栈为空代表序列正确

def IsPopOrder(self, pushV, popV):
        # write code here
        if pushV == [] or len(pushV) != len(popV):
            return None
        stack,index = [],0
        for item in pushV:
            stack.append(item)
            while stack and stack[-1] == popV[index]:
                stack.pop()
                index += 1
        '''
        if stack == []:
            return True
        else:
            return False
        '''
        return True if stack == [] else False
1415
16
17