一、算法概念
算法：就是一个计算过程，解决问题的方法。
二、递归
2.1、递归特点
递归算法是一种直接或间接调用自身算法的过程，在计算机编程中，它往往使算法的描述简洁而且易于理解。
递归算法解决问题的特点：
（1）递归就是在过程或函数里调用自身。
（2）在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
（3）递归算法解题通常显得很简洁，但递归算法解题的运行效率较低，所以一般不提倡用递归算法设计程序。
（4）在递归调用的过程中系统为每一层的返回点、局部量等开辟了新栈来存储，递归次数过多容易造成栈溢出等。
递归的要求
递归算法所体现的“重复”一般有三个要求：
（1）每次调用在规模上都有所缩小（通常是减半）。
（2）是相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出作为后一次的输入）。
（3）在问题的规模极小时必须直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的（以规模未达到直接解答的大小为条件）无条件递归调用将会成为死循环而不能正常结束。
2.2、简单的递归函数实例：
def recursion(i): #定义函数
print(i)
if i/2 > 1: #判断递归条件，退出
re = recursion(i/2) #递归函数自身
print('返回值:',re)
print('上层递归值：',i)
return i #返回值
recursion(10)
#运行原理：首先运行函数传参10给函数，打印10，判断条件满足，递归
#函数参数值为（10/2）5，打印i的值5，等递归到1.25时，判断条件不满
#足后，才打印上层递归的值，此时递归的值为1.25，return递归最后一
#层的值1.25，退出最后一层递归，继续一层层退出递归，最后返回最上层
#递归值结束函数。
'''
10
5.0
2.5
1.25
上层递归值： 1.25
返回值: 1.25
上层递归值： 2.5
返回值: 2.5
上层递归值： 5.0
返回值: 5.0
上层递归值： 10
'''
斐波那契数列：就是前两个数的和为后一个数的值（0，1，1，2，3，5，8，13…）
def foo(arg1,arg2,stop):
if arg1 == 0:
print(arg1,arg2)
arg3 = arg1 + arg2
print(arg1,arg2,arg3)
if arg3 < stop: #判断套件不满足时退出递归
foo(arg2,arg3,stop) #递归函数，传送参数arg2,arg3,stop给arg1,arg2,stop
foo(0,1,50)
'''
0 1
0 1 1
1 1 2
1 2 3
2 3 5
3 5 8
5 8 13
8 13 21
13 21 34
21 34 55
'''
利用切片递归方式，查找数据：
def twosplit(sourceDate,findData):
sp = int(len(sourceDate)/2) #序列长度
if sourceDate[0] == findData:
print('找到数据:',sourceDate[0])
return 0
else:
if findData in sourceDate[:sp]: #判断在左边
print('数据在左边[%s]' %sourceDate[:sp])
twosplit(sourceDate[:sp],findData) #递归函数
elif findData in sourceDate[sp:]: #判断在右边
print('数据在右边[%s]' %sourceDate[sp:])
twosplit(sourceDate[sp:], findData)
else:
print('找不到数据')
if __name__ == '__main__':
data = [1,2,'c',3,4,5,6,7,8,17,26,15,14,13,12,11,'a','b']
#data = list(range(1000000))
twosplit(data,'c')
二位数组，顺时针90度数据调换：
a = [[col for col in range(4)] for row in range(4)]
for i in a:print(i) #打印二维数组
print('--------------------')
for lf,rig in enumerate(a): #循环数组，打印数组下标和元素
for cf in range(lf,len(rig)): #从下标数组开始循环到列表长度
tmp = a[cf][lf] #存储列表元素中的元素
a[cf][lf] = rig[cf]
a[lf][cf] = tmp
print('+++++++++++++++++')
for i in a:print(i)
'''
#另一种方法
for i in range(len(a)):
ai = [a[i][i] for row in range(4)]
print(ai)
'''
2.3、递归原理
函数调用时，函数会开一个新栈，在新栈中执行这个函数体中的代码。
2.3.1、print() 语句在递归前
在函数调用前的代码会依次执行完之后再执行后面的函数调用。
2.3.2、print() 语句在递归后
在函数调用后的代码会等到函数所有调用执行完之后再从里到外依次执行。
三、二分查找
每次能够排除掉一半的数据，查找的效率非常高，但是局限性比较大； 必须是有序列表才可以使用二分查找。
# 1.非递归算法
def binary_search(lis, nun):
left = 0
right = len(lis) - 1
while left <= right: #循环条件
mid = (left + right) // 2 #获取中间位置，数字的索引（序列前提是有序的）
if num < lis[mid]: #如果查询数字比中间数字小，那就去二分后的左边找，
right = mid - 1 #来到左边后，需要将右变的边界换为mid-1
elif num > lis[mid]: #如果查询数字比中间数字大，那么去二分后的右边找
left = mid + 1 #来到右边后，需要将左边的边界换为mid+1
else:
return mid #如果查询数字刚好为中间值，返回该值得索引
return -1 #如果循环结束，左边大于了右边，代表没有找到
lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
print(lis)
lis.sort()
print(lis)
while 1:
num = int(input('输入要查找的数：'))
res = binary_search(lis, num)
print(res)
if res == -1:
print('未找到！')
else:
print('找到！')
# 2.递归算法
def binary_search(lis, left, right, num):
if left > right: #递归结束条件
return -1
mid = (left + right) // 2
if num < lis[mid]:
right = mid -1
elif num > lis[mid]:
left = mid + 1
else:
return mid
return binary_search(lis, left, right, num)
#这里之所以会有return是因为必须要接收值，不然返回None
#回溯到最后一层的时候，如果没有return，那么将会返回None
lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
print(lis)
lis.sort()
print(lis)
while 1:
num = int(input('输入要查找的数：'))
res = binary_search(lis, 0, len(lis)-1,num)
print(res)
if res == -1:
print('未找到！')
else:
print('找到！')