说的简单一点就是占用内存空间的多少，但是现在不怎么考虑了
递归1. 调用自己
2.终止条件
汉诺塔问题
# 汉诺塔问题
def hannoi(n,a,b,c):
if n>0:
hannoi(n-1,a,c,b)
print("from %s to %s"%(a,c))
hannoi(n-1,b,a,c)
if __name__ == '__main__':
hannoi(3,"a","b","c")
查找
顺序查找
def search(li,div):
for ind,v in enumerate(li):
if v==div:
return ind
else:return None
div=3
li=[1,2,3,4,5,6,7]
print(search(li,div))
二分查找
注意 ：二分查找要基于数据是排好序的状态才能使用
'''
这个编程 是二分法查找
'''
def binary_search(li,val):
left=0;
right=len(li)-1
while left<=right:
mid=(left+right)//2
if(li[mid]==val):
return mid
elif(li[mid]>val):
right=mid-1
elif(li[mid]
排序
选择排序
原理是 每次都挑选出来列表中最小的一个数出来 将他放在前面
list =[1,5,3,7,6,4,2,8]
for i in range(len(list)):
min=i
for j in range(i+1,len(list)):
if(list[min]>list[j]):
list[min],list[j]=list[j],list[min]
print(list)
插入排序
摸牌排序
def insert_sort(li):
for i in range(1,len(li)):
temp=li[i] # 要摸n-1次
j=i-1 #j是手中的牌
while j>=0 and li[j]>temp:
li[j+1]=li[j]
j-=1
li[j+1]=temp
if __name__ == '__main__':
list=[0,1,3,5,4,7,6,9,8]
insert_sort(list)
print(list)
Nb三人组
快速排序
思路： 找一个值作为分界点，将头和尾部进行遍历与分界点的值进行比较，左边全为比分界点的值要小的值，右边是比分界点的值要大的值。通过递归进行更加细致的排列，最终形成有序
def partition(li,left,right):
temp=li[left]
while left=temp:
right-=1 #一直往右找比基准值小的数
li[left]=li[right]
while left
堆排序
树：由字面理解，数据排布方式就像一颗树一样有根和叶
有比较特殊的两种树 如下图显示
顺序的存储方式其实就是从上往下再加上从左往右的顺序去数
大根堆与小根堆
堆排序的过程
代码
def sift(li,low,high):
'''
:param li: 列表
:param low:堆的根节点
:param high: 堆的最后一个叶子节点
:return:
'''
i=low #i是最开始指向根节点
j=2*i+1 #j是开始的左孩子
tmp=li[low] #把顶部存起来
while j<=high:
if j+1<=high and li[j+1]>li[j]:
j=j+1
if li[j]>tmp:
li[i]=li[j]
i=j
j=2*j+1
else:
li[i]=tmp
break
else:li[i]=tmp
def heap_sort(li):
n=len(li)
for i in range((n-2)//2,-1,-1):
sift(li,i,n-1)
#堆建完了
for i in range(n-1,-1,-1):
li[0],li[i]=li[i],li[0]
sift(li,0,i-1)
if __name__ == '__main__':
li=[i for i in range(100)]
import random
random.shuffle(li)
print(li)
heap_sort(li)
print(li)
堆排序topk问题
就是找到前k个最大或者最小的数
注意：关于稳定，是指相同值的两个数排序后的相对位置是否发生改变
归并排序
思路：将无序列表切割，分成各个部分，再进行组合形成有序
def merge(li,low,high):
i=low
mid=(low+high)//2
j=mid+1
litmp=[]
while i<=mid and j<=high:
if li[i]
其他排序
希尔排序 
