Python入门之递归函数

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归函数特性：

1. 必须有一个明确的结束条件；
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。
4. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

先举个简单的例子：计算1到100之间相加之和；通过循环和递归两种方式实现

#!/usr/bin/env python3
# 1-100 sum

import sys
def sum_cycle(n):
    '''
    1 to n,The sum function
    '''
    sum = 0
    for i in range(1,n + 1):
        sum += i
    return sum

def sum_recu(n):
    '''
    1 to n,The sum function
    '''
    if n > 0:
        return n + sum_recu(n - 1)　　　　#调用函数自身
    else:
        return 0
print("循环求和：",sum_cycle(100))
print("递归求和：",sum_recu(100))
执行结果：
[root@localhost tmp]# ./sum.py
循环求和： 5050
递归求和： 5050

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

***使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

把上面的递归求和函数的参数改成10000就导致栈溢出！

[root@localhost tmp]# ./sum.py
循环求和： 5050
Traceback (most recent call last):
  File "./sum.py", line 23, in <module>
    print("递归求和：",sum_recu(1000))
  File "./sum.py", line 19, in sum_recu
    return n + sum_recu(n - 1)
  File "./sum.py", line 19, in sum_recu
    return n + sum_recu(n - 1)
  File "./sum.py", line 19, in sum_recu
    return n + sum_recu(n - 1)
  [Previous line repeated 994 more times]
  File "./sum.py", line 18, in sum_recu
    if n > 0:
RecursionError: maximum recursion depth exceeded in comparison

***解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归优化：http://www.open-open.com/lib/view/open1480494663229.html

二分法查找大家应该听说过；就是一种快速查找的方法，时间复杂度低，逻辑简单易懂，总的来说就是不断的找出中间值，用中间值对比你需要找的实际值；若中间值大，则继续找左边；若中间值小，则继续找右边；可以看出二分法就是不断重复此上过程，所以就可以通过递归方式来实现二分法查找了！

#!/usr/bin/env python3

#The binary search function

def  Binary_Search(data_source,find_n):
    if len(data_source) >= 1:                                           #判断列表长度是否大于1，小于1就是一个值
        mid = int(len(data_source)/2)                                   #获取列表中间索引；奇数长度列表长度除以2会得到小数，通过int将转换整型
        if find_n > data_source[-1]:                                    #判断查找值是否超出最大值
            print('{}查找值不存在！'.format(find_n))
            exit()
        elif find_n < data_source[0]:                                   #判断查找值是否超出最小值
            print('{}查找值不存在！'.format(find_n))
            exit()
        if data_source[mid]  > find_n:                                  #判断列表中间值是否大于查找值
            #print('查找值在 {} 左边'.format(data_source[mid]))
            Binary_Search(data_source[:mid],find_n)                     #调用自己，并将中间值左边所有元素做参数
        elif data_source[mid] < find_n:                                 #判断列表中间值是否小于查找值
            #print('查找值在 {} 右边'.format(data_source[mid]))           #调用自己，并将中间值右边所有元素做参数
            Binary_Search(data_source[mid:],find_n)
        else:
            print('找到查找值',data_source[mid])                          #找到查找值
    else:
        print('{}查找值不存在！'.format(find_n))                          #特殊情况，返回查找不到

Data = [22,12,41,99,101,323,1009,232,887,97]
Data.sort()                                                             #列表从小到大排序
Binary_Search(Data,323)                                                 #查找323
执行结果：
[root@localhost tmp]# ./binary_search.py 
找到查找值 323