递归及其应用

递归的定义

• 直接或间接 调用自身

 

• 算法思想：

 

        • 原问题可分解子问题（必要条件）

        • 原与分解后的子问题相似（递归方程）

        • 分解次数有限（子问题有穷）

        • 最终问题可直接解决（递归边界）

递归的经典问题：

• 斐波那切数列

• 汉诺塔问题

• 快速排序

• 二叉树遍历

1.斐波那切数列

python实现：

import numpy as np

fibn = np.zeros(100) 

def fib(n): 
    if n == 0:
        return 1
    if n == 1:
        return 1
    if fibn[n] > 0:  #当不为0的时候就不用计算了，直接返回，所以整个递归只需要计算n次加法
        return fibn[n]   
    else:
        fibn[n] = fib(n-1)+fib(n-2)
        return fibn[n]
    

这里在函数前面定义了一个列表是为了避免重复计算浪费资源。

那么是否还可以进行优化呢？（可以直接利用公式求解）

2.汉诺塔

python实现：

#汉诺塔问题
i = 0
def hannuota(n,a,b,c):
    global i  #避免python将i视为local变量
    if n == 0:
        return
    hannuota(n-1,a,c,b)
    print(str(n) + '\t' + a + '\t' + c)
    i +=1
    hannuota(n-1,b,a,c)
    
hannuota(3,'A','B','C')
print(i)

3.快速排序

python实现：

# f = [2,5,3,1,9,8,3,7,8,88,7,6,6,2,1,5,4]
import numpy as np
f = np.random.randint(0,100,size=100000)
def quicksort(L,R):#  L为起点，R为终点
    m = f[L]
    i = L 
    j = R
    while (i <= j):
        while (i <= j and f[i] < m):
            i+=1
        while (i <= j and f[j] > m):
            j-=1
        if (i <= j):
            f[i],f[j] = f[j],f[i]
            i+=1
            j-=1
    if (L < j):
        quicksort(L,j)
    if (i < R):
        quicksort(i,R)

quicksort(0,len(f)-1)
print(f)

4.二叉树遍历

这里只介绍思想：