算法基础
算法
算法（Algorithm）：一个计算过程，解决问题的方法。
时间复杂度
时间复杂度是用来估计算法运行时间的一个式子（单位）。
当循环少一半的时候 时间复杂度O(logn)
几次关于n的循环就是n的几次方的复杂度
print('Hello World') #假如说这行代码运行时间是一个单位O(1) for i in range(n): # 这段代码的时间是O(n),因为执行了n次 print('Hello World') for i in range(n): # 这段代码是O(n*n),因为在执行了n*n次 for j in range(n): print('Hello World') for i in range(n): #这代码是O(n*n*n),执行了n的立方次 for j in range(n): for k in range(n): print('Hello World')
一般来说，时间复杂度高的算法比复杂度低的算法慢。
常见的时间复杂度（按效率排序）： O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n2logn)<O(n3)
空间复杂度
空间复杂度：用来评估算法内存占用大小的一个式子
空间换时间：多给它一些空间或内存，让它运行速度更快
递归
特点:
- 1.调用自身
- 2.有结束条件
def func(x): if x>0: print(x) func(x-1) print(4) # 打印结果 4 3 2 1 #因为先打印再递归
def func(x): if x > 0: func(x-1) print(x) func(4) # 打印结果 1 2 3 4 # 因为先递归，再打印
那么递归前先打印,和递归后再打印有什么不同?
如果先递归再打印,那么打印的内容先不被执行,直到递归跳出的时候才从内到外的进行打印.
打印抱着抱着抱着我的小可爱的我的我的我
def text(n): if n>0: print('抱着',end='') text(n-1) print('的我',end='') else: print('我的小可爱',end='') text(3)
二分查找
关键点:
候选区data[0:n]
def bin_search(li, val): # li是传入的列表 val是要查找的值 low = 0 # low是起始的索引值 high = len(li) - 1 # high是末尾的索引值 while low <= high: # 满足起始索引小于末尾索引的条件就执行循环 mid = (low + high) // 2 # mid是列表的中间数的索引 if li[mid] == val: # 正好找到要查找的值的索引 return mid elif li[mid] < val: # 中间数的值小于被查找的值 low = mid + 1 # 说明val在中间数的右边 else: high = mid - 1 # 说明val在中间数的左边
尾递归二分查找:
def bin_search_rec(data_set, value, low, high): if low <= high: mid = (low + high) // 2 if data_set[mid] == value: return mid elif data_set[mid] > value: return bin_search_rec(data_set, value, low, mid - 1) else: return bin_search_rec(data_set, value, mid + 1, high) else: return
二分查找：从有序列表的候选区data[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。
输出查询的列表值的下标
既然二分查找那么快为什么不全部都用二分查找呢?
因为二分查找的前提是列表是有序的,那么如何让无序的列表变成有序才是最大的问题.
列表排序
冒泡排序
冒泡排序：两层遍历，相邻的两个值，如果左边的数大于右边的数，则交换位置。
def bubble_sort(li): '''冒泡排序''' for i in range(0,len(li)-1): exchange=False for j in range(0,len(li)-i-1): # 设置终点值 if li[j]>li[j+1]: # 判断是否大于 li[j],li[j+1]=li[j+1],li[j] # 交换位置 exchange=True # 优化,如果不为true说明了没有进行交换,列表是有序的 if not exchange: return li=list(range(0,10000)) random.shuffle(li) bubble_sort(li) print(li)
时间复杂度为O(n**2)
选择排序
选择排序：遍历一趟记录最小的数，放到第一位。再遍历剩下的数，找的最小的数，继续放置。
关键点：无序区和最小数的位置。
def select_sort(li): ''' 选择排序,比较无序区最小的一个,放在有序曲后一个 :param li: 列表 :return: ''' for i in range(0,len(li)-1): min_local=i for j in range(i+1,len(li)): if li[min_local] > li[j]: min_local=j li[i],li[min_local]=li[min_local],li[i] li=list(range(0,10000)) random.shuffle(li) select_sort(li) print(li)
时间复杂度为O(n**2)
插入排序
列表被分为有序区和无序区两个部分。最初有序区只有一个元素。
每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空。
代码关键点：如何找到无序区数，如何插到有序区中。
def inser_sort(li): '''插入排序, 从i开始表示摸牌的位置, 与前面的数进行相比,如果比摸的牌大则挪一位''' for i in range(1,len(li)): j=i-1 temp=li[i] while j>=0 and li[j]>temp: li[j+1] = li[j] j-=1 li[j+1]=temp li=list(range(0,10000)) random.shuffle(li) inser_sort(li) print(li)
类似于摸牌然后插入
时间复杂度为O(n**2)
快速排序
快速排序：取一个元素p（第一个元素），使元素p归位，列表被p元素分为两部分，左边都比p小，右边都比p大，然后递归完成排序。
import random def partition(li, left, right): i=random.randint(left,right) li[left],li[i] = li[i],li[left] tem=li[left] while left < right: # 列表里至少两个元素才满足这个条件 while left < right and li[right] >= tem: # 从右边边找小于tem的数 right -= 1 # 如果不小于，继续找 li[left]= li[right] # 找到比tem小的数，挪到左边 while left < right and li[left] <= tem: # 从左边找比tem大的数 left += 1 li[right]= li[left] li[left] = tem return left # 这里返回left和right是一样的 def quick_sort(li, left, right): if left < right: # 列表里至少两个元素才满足这个条件 mid = partition(li, left, right) quick_sort(li, left, mid-1) # 递归 quick_sort(li, mid+1, right) # 递归 li=list(range(10000,0,-1)) random.shuffle(li) ret=quick_sort(li,0,len(li)-1) print(li)
快速排序的时间复杂度 为O(nlogn)
堆排序
知识点介绍
- 根节点、叶子节点
- 没有父亲的节点叫根节点,比如A, 没有孩子的节点叫叶子节点,比如BCHPQ等等
- 树的深度
- 有多少层,图示是4层
- 树的度
- 树的度势节点度的最大值比如A的度是6,E的度是2,F的度是3
- 孩子节点/父节点
- 子树
- 在同一个分支上的是子树,只有一个的也是子树
二叉树
度不超过2的树(节点最多有两个)
- 满二叉树:一个二叉树
- 如果每一层的节点都达到了最大值,则这个二叉树就是满二叉树
- 完全二叉树
- 叶节点只能出现在最下层和次下层,并且最下层的节点都集中在最左边的若干位置的二叉树
父亲节点和左孩子节点有什么位置关系?
0-1 1-3 2-5 3-7 4-9
i=2i+1
右父亲节点和孩子节点有什么位置关系?
0-2 1-4 2-6 3-8 3-10
i=2i+2
堆
- 大根堆
- 一颗完全二叉树,满足任一节点都比孩子大
- 小根堆
- 一颗完全二叉树,满足任一节点都比孩子小
如何构建一个堆
挨个出数
- 结果就是成立一个新的堆
再然后就是把8放到有序列表中,把最后的子节点替代根节点然后向下调整
堆排序的代码
def sift(li,low,high): temp=li[low] #根节点 i=low j=2* i + 1 # i是他的孩纸坐标 while j <= high: if j < high and li[j+1]>li[j]: #如果右孩子存在,且右孩子的值大于左孩子 j+=1 if temp<li[j]: #如果根节点的值小于他的孩子 li[i] = li[j] # 将孩子放置到根节点上 i=j #更新i的坐标值 j= 2* i +1 #更新i的坐标值 else: # 如果根节点大于两个孩子节点 li[i]=temp #放置在根节点上 结束. break else: li[i] = temp # 第二种跳出情况,temp找到自己的位置跳出,放置到i def heap_sort(li): n=len(li) # 1.建堆的过程 for i in range(n//2-1,-1,-1): # 最后一个非叶子节点的位置是n//2 -1 sift(li,i,n-1) # 2. 诶个出数 for i in range(n-1,-1,-1): li[0],li[i]=li[i],li[0] sift(li,0,i-1) import random li=list(range(0,100000)) random.shuffle(li) heap_sort(li) print(li)
归并排序
归并算法的核心就是拆分列表,在合并的过程中进行排序
def merge(li, low, mid, high): # high是右边片段最后一个数的索引 li_tem = [] i = low # low是左边片段第一个数的索引 j = mid + 1 # mid是左边片段最大的数的索引 while i <= mid and j <= high: # 如果左右两个片段都有值，就继续取值。只要其中一个片段没值，就跳出循环。 if li[i] < li[j]: # 如果左边片段的最小值小于右边的最小值 li_tem.append(li[i]) # 就将最小的那个值取出来放到一个列表中。 i += 1 # 然后继续比较剩下的最小值 else: # 反之，就是右边的最小值小于左边的最小值 li_tem.append(li[j]) j += 1 # 然后继续比较剩下的最小值 # 跳出第一个while循环的条件是：如果左边的片段取完了，其索引i不小于mid了 # 如果右边的片段取完了，其索引j就不小于high了 # 下面的两个while循环只可能有一个执行 while i <= mid: # 这里是左偏片段还有值 li_tem.append(li[i]) i += 1 # 继续添加到列表中 while j <= high: # 这里是右边片段还有值 li_tem.append(li[j]) j += 1 # 继续添加到列表中 li[low:high+1] = li_tem def merge_sort(li, low, high): if low < high: # 保证列表至少有两个元素 mid = (low + high) // 2 # 取中间数的索引 merge_sort(li, low, mid) # 将左边的通过递归编程有序列表 merge_sort(li, mid+1, high) # 将右边的通过递归编程有序列表 merge(li, low, mid, high) # 将左右两个片段合并成一个有序列表 li = [2, 5, 7, 8, 9, 1, 3, 4, 6, 10] merge_sort(li, 0, len(li)-1) print(li)
后三种算法总结
三种排序算法的时间复杂度都是O(nlogn)
一般情况下，就运行时间而言：
- 快速排序<归并排序<堆排序
三种排序算法的缺点：
- 快速排序：极端情况下，排序效率低
- 归并排序：需要额外的内存开销
- 堆排序：在快的排序算法中相对较慢
那么稳定与不稳定是什么呢?
稳定的排序是指在排序相同数字的时候不打乱原有的顺序,
比如[ (1,'alex') ,(1,'egon'),(2,'ming') ]
在排序的时候不打乱原有的数据顺序.
[ (1,'egon'),(1,'alex') ,,(2,'ming')]如果不确定是否会打乱原有顺序的则是不稳定的.
相邻比较的都是稳定的.
