day4递归原理及实现

递归

特定：

　　递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题十分有效，它往往是算法的描述简洁而且易于理解。

　　递归算法解决问题的特点：

　　（1）递归就是在过程或函数里调用自身。

　　（2）在使用递归测略时，必须有一个明确的递归结束条件，称为递归出口。

　　（3）递归算法解题通常显得很简洁，但递归算法解题的效率较低。所以一般不提倡递归算法设计程序。

　　（4）在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

要求：

　　递归算法所体现的“重复”一般有三个要求：

　　一是每次调用在规模上都有所缩小（通常是减半）；

　　二是相邻两次重复之间有密切的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）；

　　三是在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的（以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

　　下面来看一个简单的递归程序：

　　def calc(n):
　　　　print(n)
　　　　if n/2 >1:
　　　　　　res = calc(n/2)

　　　　　　#print语句是不会执行的，因为在执行的过程中，一致在调用函数，只有退出的时候return把返回值传递给res才会执行
　　　　　　print("res:",res)
　　　　print("N:",n)

　　　　#上面递归运算完成之后，把返回值返回给res，递归多少层，退出就有多少层
　　　　return n

　　calc(10)

　　运行如下：

　　10
　　5.0
　　2.5
　　1.25
　　N: 1.25
　　res: 1.25
　　N: 2.5
　　res: 2.5
　　N: 5.0
　　res: 5.0
　　N: 10　

　　斐波那契数列指的是这样一个数列0，1，1，2，3，5，8，13，21，34，55，89，144，233，377，610，987，1597，2584，4181，6765  ......　

　　def func(arg1,arg2,stop):
　　　　if arg1 == 0:
　　　　　　print(arg1,arg2)
　　　　arg3 = arg1 + arg2
　　　　print(arg3)
　　　　if arg3 < stop:

　　　　　　#把arg2,arg3作为新的参数传递给函数
　　　　　　func(arg2,arg3,stop)

　　func(0,1,30)

　　上面代码使用递归算法，每次调用函数并进行后面的数字相加，知道条件不满足位置，func(arg2,arg3,stop)是将arg2,arg3作为新的参数调用函数，此时函数重新执行，调用函数。

算法基础之二分法：

　　有一个有序列表，判断一个数是否在列表中，data = list(range(1,6000,3)),现在判断3001是否在列表中。

　　1.通过递归实现2分查找

　　现有列表primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],要求二等用最快的方式找出23。请Low B，Low 2B，Low 3B三个同学来回答这个问题。

　　Low B：这个问题很简单，直接用data.__contains__(23)，语音未落就被老板打了，让你自己实现，不是让你用现成的功能，Low B于是说，那只能从头开始一个一个数了，然后Low B被开除了.....

　　Low 2B：因为这个列表是有序的，我们可以把列表从中截取一半，大概如下：

　　p1 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,41]

　　p2 = [ 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

　　然后看p1[-1]也就是41是否比23大，如果比23大就代表肯定在p1里面，否则那就肯定在p2里面。现在我们知道23比41小，所以23肯定在p1里面，但p1里依然有很多元素，怎么找到23呢？很简单，依然按照上一次的方法，把p1分成2部分，如下：

　　p1_a = [2, 3, 5, 7, 11, 13,17]

　　p1_b = [19, 23, 29, 31, 37,41]

　　然后我们发现，23比p1_a最后一个值17大，那代表23肯定在p1_b中，p1_b中依然有很多元素，那就再按之前的方法继续分半，最终用不了几次，肯定就把23找出来了！

　　说完，Low BB满有成就感的甩了下头上的头皮屑。

　　老板说：很好，确实较Low B的方案强很多。然后转头就问Low 3B,你有更好的想法么？

　　Low 3B: 啊。。。噢 ，我。。。我跟Low 2B的想法一样，结果被他说了。

    Low BBB：啊。。。噢 ，我。。。我跟Low 2B的想法一样，结果被他说了。

　　Low BBB此时冷汗直冒，因为他根本没思路，但还是硬着头皮去写了。。。。虽然自己没思路，但是会谷歌呀，三个小时过去了，终于憋出了以下代码：

　　def binary_search(data_source,find_n):
    　　mid = int(len(data_source)/2)
    　　if mid >= 1:
        　　#递归必须有结束条件，这里的结束条件是当列表只有两个长度的时候运算终止
        　　if data_source[mid] > find_n: #查找的值在中间值的左边
            　　print("data in left of [%s]" %data_source[mid])
            　　#print(data_source[:mid])
           　　 binary_search(data_source[:mid],find_n)
       　　 elif data_source[mid] < find_n:
            　　print("data in right of [%s]" %data_source[mid])
            　　#print(data_source[mid:])
            　　binary_search(data_source[mid:],find_n)
       　　 else:
            　　print("found find_n: ",data_source[mid])
   　　 else:
       　　 print("cannot finding....")


　　if __name__ == '__main__':

    　　data = list(range(1,6000000,3))
    　　#print(data)

　　binary_search(data,53)

　　上面代码中，我们的思想是这样的，如果我们直接23 in data的话，是遍历列表，列表多长就遍历多少次，我们可以使用二分法来解决，由于列表是有序的，我们可以先取中间值data_source[mid]，拿这个值与我们要查找的值进行比较，如果data_source[mid]中间值大于查找的值，说明要找的值的范围在中间值的左侧；反之在中间值的右侧，如果与中间值相等，那么这个值就等于中间值，就不需要在查找了。以上过程进行递归反复，就能够找到哦我们所需的结论，我们知道，每次查找的过程中列表的长度都是减半的。递归要有结束条件，我们想，当列表只有两个值的时候就应该停止，没有必要在进行递归了，因为要么等于，要么不等于，如果等于就打印找到了，如果没有就打印找不到。

　　运行结果如下：

　　data in left of [3000001]
　　data in left of [1500001]
　　data in left of [375001]
　　data in left of [187501]
　　data in left of [93751]
　　data in left of [46876]
　　data in left of [23437]
　　data in left of [11719]
　　data in left of [5860]
　　data in left of [2929]
　　data in left of [1465]
　　data in left of [733]
　　data in left of [367]
　　data in left of [184]
　　data in left of [91]
　　data in right of [46]
　　data in left of [67]
　　data in left of [55]
　　data in right of [49]
　　found find_n:  52

    上面代码我们就运行了20次就结束查找了，大大减少了遍历的次数，如果使用in需要遍历6000000次，所以使用一些简单的算法能够大大节约我们的时间。但是上面程序也有一个bug就是查找不到1，为什么呢？因为我们在判断的过程中，一直判断的是data_source[mid]>0，我们知道，那么如果我们要判断1，那么我们知道，没有比1更小的数，而上面代码比较的是data_source[data]大于、等于、小于find_n，如果满足则没有关系，如果不满足则提示查找不到，这是有明显缺陷的，因为没有判断最小的值，因为我们要对data_source[0]进行判断，如何判断呢？就只需要在mid == 1的时候判断即可，我们知道，在mid == 1的时候必然是只剩下两个元素了，只要我们判断两个元素的情况即可，判断data_source[0]和data_source[0]是否与查找的数相等，如果相等则返回查找到了，否则必然是查找不到的情况。修改后的代码如下：

    def binary_search(data_source,find_n):
　　　　mid = int(len(data_source)/2)
　　　　if mid > 1:
　　　　#递归必须有结束条件，这里的结束条件是当列表只有两个长度的时候运算终止
　　　　　　if data_source[mid] > find_n: #查找的值在中间值的左边
　　　　　　　　print("data in left of [%s]" %data_source[mid])
　　　　　　　　#print(data_source[:mid])
　　　　　　　　binary_search(data_source[:mid],find_n)
　　　　　　elif data_source[mid] < find_n:
　　　　　　　　print("data in right of [%s]" %data_source[mid])
　　　　　　　　#print(data_source[mid:])
　　　　　　　　binary_search(data_source[mid:],find_n)
　　　　　　else:
　　　　　　　　print("found find_n: ",data_source[mid])
　　　　elif mid == 1:
　　　　　　if data_source[mid] == find_n or data_source[0] == find_n:
　　　　　　　　print("found find_n: ",find_n)
　　　　　　else:
　　　　　　　　print("cannot finding....")
　　　　# else:
　　　　　　# print("cannot finding....")

　　if __name__ == '__main__':

　　　　data = list(range(1,600,3))
　　　　#print(data)

　　binary_search(data,4)

 

　　上述代码中，我们加入了当mid == 1的时候对代码的判断，只要加上这么一个小小的判断就能够避免1查找不到的尴尬，修复了bug.