0. 相关概念

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
• 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
• 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
• 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
  

一. 冒泡排序

算法过程：
进行N-1趟操作，每一趟，都是不断的比较相邻的元素，那么一趟下来，就会将最大的移到排好顺序的最后面的位置。

代码实现：

def bubble_sort(alist):"""冒泡排序：最优时间复杂度：O（n）最坏时间复杂度：O（n^2）稳定性：稳定"""n = len(alist)for j in range(n-1):for i in range(0,n-1-j):if alist[i] > alist[i+1]:alist[i],alist[i+1] = alist[i+1],alist[i]return liif __name__ == '__main__':li = [54,26,93,17,77,31,44,55,20]print(li)li = bubble_sort(li)print(li)

二. 选择排序

算法过程：
初始状态：无序区为R[1…n]，有序区为空；

第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

n-1趟结束，数组有序化结束。

代码实现：

def select_sort(alist):"""选择排序最优时间复杂度：O（n^2）最坏时间复杂度：O（n^2）稳定性：不稳定"""n = len(alist)for j in range(n-1):min_index = jfor i in range(j+1,n):if alist[min_index] > alist[i]:min_index = ialist[j],alist[min_index] = alist[min_index],alist[j]if __name__ == '__main__':li = [54,26,93,17,77,26,31,44,55,20]print(li)select_sort(li)print(li)

三. 插入排序

算法过程：
从第一个元素开始，该元素可以认为已经被排序；

取出下一个元素，在已经排序的元素序列中从后向前扫描；

如果该元素（已排序）大于新元素，将该元素移到下一位置；

重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

将新元素插入到该位置后；

重复步骤2~5。

代码实现：

def insert_sort(alist):"""插入排序：最优时间复杂度:O(n)最差时间复杂度：O(n^2)稳定性：稳定"""n = len(alist)for j in range(1, n):i = jwhile i > 0:if alist[i] < alist[i-1]:alist[i], alist[i-1] = alist[i-1], alist[i]i -= 1else:breakif __name__ == '__main__':li = [54,26,93,17,77,31,44,55,20]print(li)insert_sort(li)print(li)

四. 希尔排序

算法过程：
选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

按增量序列个数k，对序列进行k 趟排序；

每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

代码实现：

def shell_sort(alist):"""shell排序：最优时间度：根据步长序列的不同而不同最差时间度：O(n^2)稳定性：不稳定"""n = len(alist)gap = n // 2while gap > 0:# 希尔排序与插入排序的区别就是gap步长for j in range(gap,n):i = jwhile i > 0:if alist[i] < alist[i - gap]:alist[i], alist[i-gap] = alist[i-gap], alist[i]i -= gapelse:break# 缩短gap步长gap //= 2if __name__ == '__main__':li = [54,26,93,17,77,26,31,44,55,20]print(li)shell_sort(li)print(li)

五. 快速排序

算法过程：
从数列中挑出一个元素，称为 “基准”（pivot）；

重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

代码实现：

def quick_sort(alist,first,last):"""快速排序：最优复杂度：O（nlogn）最坏复杂度：O（n^2）稳定性:不稳定"""if first >= last:returnmid_value = alist[first]low = firsthigh = lastwhile low < high:while low < high and alist[high] >= mid_value:high -= 1alist[low] = alist[high]while low < high and alist[low] < mid_value:low += 1alist[high] = alist[low]# 从循环退出时，low=highalist[low] = mid_value# 对low左边的列表执行快速排序quick_sort(alist,first,low-1)# 对low右边的列表排序quick_sort(alist,low+1,last)if __name__ == '__main__':li = [54, 26, 93, 17, 77, 31, 44, 55, 20]print(li)quick_sort(li, 0, len(li)-1)print(li)

六. 归并排序

算法过程：

把长度为n的输入序列分成两个长度为n/2的子序列；

对这两个子序列分别采用归并排序；

将两个排序好的子序列合并成一个最终的排序序列。

代码实现：

def merge_sort(alist):"""归并排序最优时间度：最坏时间度：稳定性："""n = len(alist)if n <= 1:return alistmid = n//2# left采用归并排序后形成的有序的新的列表left_li = merge_sort(alist[:mid])# right采用归并排序后形成的有序的新的列表right_li = merge_sort(alist[mid:])# 将两个有序的子序列合并为一个新的整体left_pointer,right_pointer = 0,0result = []while left_pointer<len(left_li) and right_pointer<len(right_li):if left_li[left_pointer] < right_li[right_pointer]:result.append(left_li[left_pointer])left_pointer += 1else:result.append(right_li[right_pointer])right_pointer += 1result += left_li[left_pointer:]result += right_li[right_pointer:]return resultif __name__ == '__main__':li = [54,26,93,17,77,31,44,55,20]print(li)li_sort = merge_sort(li)print(li_sort)

七. 其他

其他算法的详细过程请参考：https://blog.csdn.net/weixin_41571493/article/details/81875088