一、冒泡排序。
核心思想：通过双层循环遍历，每次比较两个数，如果他们顺序错误（大于或者小于），那么就把他们位置交换。
冒泡排序算法利用了双层循环，时间复杂度为O(n^2)
稳定性为：稳定
1 li=[10,2,3,5,110,55,99,88,66] 2 def bubble_sort(li): 3 count=len(li) 4 for i in range(0,count): 5 for j in range(i+1,count): 6 if li[i]>li[j]: 7 li[i],li[j]=li[j],li[i] 8 return li 9 print(bubble_sort(li))
二、插入排序。
核心思想：它把一个无序数列看成两个数列，假如第一个元素构成了第一个数列，那么余下的元素构成了第二个数列，很显然，第一个数列是有序的（因为只有一个元素嘛，肯定有序哦），那么我们把第二个数列的第一个元素拿出来插入到第一个数列，使它依然构成一个有序数列，直到第二个数列中的所有元素全部插入到第一个数列，这时候就排好序了。
插入排序的复杂度是O(n^2)
1 def insert_sort(l): 2 for i in range(1,len(l)): #无序的 3 num=l[i] 4 j=i-1 5 while j>=0 and l[j]>num: #有序的 6 7 l[j+1]=l[j] 8 j-=1 9 10 l[j+1]=num 11 return l 12 l=[1,2,4,22,5,3,66,9] 13 insert_sort(l) 14 print(l) 15
三、选择排序
每次从列表中找最小的数放前，之后从剩余列表中再找最小的数，直到把所有的数找完为止。
详解：1、把第一个数作为基准数（base）
2、把剩余的数作为一个列表和基准数进行比较，小于基准数，和base交换位置，直到把剩余所有数遍历完，找到最小的数放到i的位置。
3、然后重复步骤2
时间复杂度：n^2
1 def select_sort(l): 2 min_num=0 3 for i in range(len(l)-1): 4 min_num=i 5 for j in range(i+1,len(l)): 6 if l[min_num]>l[j]: 7 min_num=j 8 l[min_num],l[i]=l[i],l[min_num] 9 return l 10 l=[1,4,2,3,9,5,7,6,8,10] 11 print(select_sort(l))
四、快速排序
快速排序基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
[2,4,6,1,3,9,7,8]
详解：1、把第一个数2作为基准数，从右到左找比基准数小的数，找到之后和low数换位置，然后从做到找比基准数大的数，找到后和high数换位置（基准数固定，这个数字一定），当low 和 high相等的时候，就分成两组，基准数左边的数列全都小于基准数右边的数列。
2、然后把左边的数列和右边的数列分开，继续重复步骤一，找最左边的为基准数，直到所有数都排完为止。
快排复杂度：最坏的：0（n^2）
平均复杂度 ：0（nlog2n）
1 def quick_sort(array,start,last): 2 while start > last: 3 return array 4 low=start 5 high=last 6 base_num=array[low] 7 while low < high: 8 while low < high and array[high] > base_num: 9 high-=1 10 array[high]=array[low] 11 while low < high and array[low] < base_num: 12 low+=1 13 array[low]=array[high] 14 array[low]=base_num 15 quick_sort(array,start,low) 16 quick_sort(array,low+1,last) 17 return array 18 l=[1,4,6,2,9,7,3,0] 19 v=quick_sort(l,0,7) 20 print(v) 21
五、堆排序
核心思想：堆是一种数据结构，可以看作一棵树完全二叉树，这棵二叉树满足，任何一个非叶子的值都大于左右孩子节点的值。将一个无序序列调整为一个堆，就可以找出这个序列的最大值（或最小值），然后将找出的这个值交换序列最后一个值，这样有序序列元素就增加一个，无序序列就减少一个，对新的无序序列重复这样的操作，就实现了排序。
复杂度：o(nlgn)
1 def adjust_heap(array,i,size): 2 lchild=2*i+1 3 rchild=2*i+2 4 maxa=i 5 if i < size//2: 6 if lchild < size and array[lchild] > array[maxa]: 7 maxa=lchild 8 if rchild < size and array[rchild] > array[maxa]: 9 maxa=rchild 10 if maxa != i: 11 array[maxa],array[i]=array[i],array[maxa] 12 adjust_heap(array,maxa,size) 13 14 def build_heap(array,size): 15 for i in range(0,size//2)[::-1]: 16 adjust_heap(array,i,size) 17 18 def heap_sort(array): 19 size=len(array) 20 build_heap(array,size) 21 for i in range(0,size)[::-1]: 22 array[0],array[i]=array[i],array[0] 23 adjust_heap(array,0,i) 24 return array 25 array=[4,2,5,7,1,8] 26 print(heap_sort(array))
六、二分查找（针对有序序列）
思想：折半思想，取这列数的中间值，如果要查找的这个数大于中间数，可以从中间数到最后作为一个数列去查找，再取此时数列的中间数，重复这样的操作，直到找到或者取完没找到为止；小于中间数，则把开头到中间数之前作为一个数列，然后折半。--采用递归
时间复杂度：o（log2n）
1 # _*_ encoding:utf-8 _*_ 2 L=[2,5,8,11,33,66,77,88] 3 num=6 4 def binary_search(L,num): 5 if len(L)>1: 6 mid=len(L)//2 7 if L[mid]==num: 8 print('找到结果') 9 if L[mid]>num: 10 return binary_search(L[:mid],num) 11 else: 12 return binary_search(L[mid:],num) 13 14 else: 15 if L[0]==num: 16 print('找到数字了') 17 else: 18 print('此结果不在列表中') 19 20 21 binary_search(L,num)