版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
摘要
- 共实现6种排序算法。
- 每个排序算法在代码片种都有核心思想的解释。
- 关于递归在本文最后有所补充。
代码：
冒泡排序：找到最大的，然后放最后。每一次循环都可能伴随着一次交换。
def bubble_sort(alist):
'''冒泡排序'''
n = len(alist)
# 直接用n也可以
for j in range(n-1): # 控制每一次循环都能找到一个最大的。一直到倒数第二小和倒数第一小进行比较。
count = 0 # 改进之后最优时间复杂度由n^2变为n
for i in range(n-1-j): # 每一次循环找到一个最大的放最后
if alist[i] > alist[i+1]:
alist[i], alist[i+1] = alist[i+1], alist[i]
count += 1
if count == 0:
return
if __name__ == '__main__':
li = [12,53,2,200, 5,101, 89, 98, 100]
# li = [12]
bubble_sort(li)
print(li)
# 当相等时，不会交换位置，所以它是稳定的。
选择排序：选一个最小的放最开始，循环结束确定最小的。
def select_sort(alist):
'''选择排序'''
n=len(alist)
for j in range(n-1): # 默认第一个是最小的索引
min_num = j
for i in range(1+j, n): # 取出真正的最小的索引
if alist[min_num] > alist[i]:
min_num = i
alist[j], alist[min_num] = alist[min_num], alist[j] # 交换位置
# 当两数相等时，排序之后不会影响其原本所在的位置，即为稳定。
# 当以寻找最大数放置-1索引位置时，该函数是不稳定的。
alist = [17,20,93,54,77,31,44,55,226]
select_sort(alist)
print(alist)
插入排序：一直与前一个比较，比较之后再与前前一个比较，将每次比较出来的放置合适的位置。
# coding:utf-8
alist = [17,20,93,54,77,31,44,55,226]
def insert_sort(alist):
'''插入排序'''
n = len(alist)
for j in range(n-1): # 操作多少个数，代表多少次
i = j+1 # i 代表从哪个数开始操作（索引）
while i > 0: # range(j,0,-1)
if alist[i]<alist[i-1]:
alist[i],alist[i-1] = alist[i-1],alist[i]
i -= 1
# else 对程序本身没有影响，这是一个性能优化---o(n)2到o(n)（如果去掉else，需要把 i-=1（shift tab））
else:
break
insert_sort(alist)
print(alist)
# 稳定性：稳定。相同的元素的时候是不会进行交换操作的，所以稳定。
借助插入排序原理，但是比较的值不再是相邻的，而是按照一定的步长去比较。
# coding utf-8
alist = [17,20,93,54,77,31,44,55,226]
def shell_sort(alist):
'''希尔排序'''
n = len(alist)
gap = n//2 # gap取中间值(其实它是不固定的，需要根据数学来计算?)
while gap > 0: # 将gap的值不断的缩小，当gap==1的时候，实际上便是利用插入排序操作了整个序列
# 内层循环达到的效果是：每个以gap步长为基准的“子序列”是有序的，并不能代表整个序列是有序的。
for j in range(gap, n): # 一个循环处理了“子序列”的以gap为步长的元素质之间的比较。
i = j
while i > 0:
if alist[i] < alist[i-gap]:
alist[i], alist[i-gap] = alist[i-gap], alist[i]
i -= gap
else:
break
# 缩短gap步长
gap //= 2
shell_sort(alist)
print(alist)
# 时间复杂度： 假设gap取1，那么就是一个很普通的插入排序，最坏时间复杂度是o(n^2);最优时间复杂度需要根据gap的值来确定。
# 稳定：因为分成几部分对待，所以相同的数可能不在一个“子序列”，于是不稳定。
快速排序：所有比他大的都在他的右边，所有比他小的都在他的左边（默认第一个值为中间值）。
# coding:utf-8
def quick_sort(alist,first,last):
'''快速排序'''
# 递归终止条件
if first >= last: # 为什么是>号，而不是==号？ 因为递归传参的时候可能存在传递的first和low-1中的low已经相等了，这个时候first是>low-1的，而这时候first和low-1作为索引对应的值在列表中还是可以找到的，所以仍会递归，于是出现递归错误。（这里判断条件有无=都可以）
return
# 规定第一个值为中间值
mid_value = alist[first]
low = first
high = last
while low < high:
# 条件成立，height左移，循环不成立将小于中间值的放置左边
while low < high and alist[high] >= mid_value: # 等号存在的意义是将相等的数值放置右边（这是快速排序的思想决定的）。
# 另外条件low<height是不可以去掉的，假设alist[high] >= mid_value一直满足，high就会一直变小，直到已经等于low，甚至小于low的时候还没有退出循环，就会超出索引的情况了。（在第一层循环满足的情况下，第二层循环在没退出的情况下是不受第一层循环限制的）。
high -= 1
alist[low] = alist[high]
# 当退出上层循环的时候alist[height]的位置空着，所以我们判断左边的
# 条件成立，low右移，循环不成立将大于中间值的放置右边
while low < high and alist[low] < mid_value: # 由于上一个同级别循环的限制，形成了即使low无限的+1，也一定会存在alist[low] == mid_value,即退出循环，所以这一个循环的判断条件，有无low < high都可以。
low += 1
alist[high] = alist[low]
# 循环退出时 low==height
alist[low] = mid_value
# 递归
# 对low左边列表执行快速排序（low是中间值，当然这个low也可以是high，因为中间值的时候就是alist[low]==alist[high]的时候）
quick_sort(alist,first,low-1)
# 对low右边列表执行快速排序
quick_sort(alist,low+1,last)
if __name__ == '__main__':
alist = [17, 20, 93, 54, 77, 31, 44, 55, 226]
quick_sort(alist,0,len(alist)-1)
print(alist)
# 最优时间复杂度是Nlogn.(logn是因为把n等分多少次而得的)n是每次拆分需要进行n次比较。
# 最坏时间复杂度是n2 第一个n是因为需要对每个元素操作 第二个n是因为每次对其中的一个元素操作的时候还要对n-1个元素操作。所以n*（n-1）约等于n^2
# 不稳定（参考二层循环中的第一个循环）
归并排序：先把数列拆开（拆到不能再拆了），然后依次往上按照升序来合并。
# coding:utf-8
def merge_sort(alist):
'''归并排序'''
n = len(alist)
if n <= 1: # 递归退出条件
return alist # 这个返回值是由最后一次调用递归的那个函数接受的（拆分到不能拆分了就返回了），也就是被left_li或者right_li接受了。这时并不会终止程序，只会终止此次递归,而后这次递归返回的数据也就是（left_li和right__li）都会进行下面的循环代码,之后返回值result_list便是可进行下面循环代码的递归函数来接受的，还是用（left_li或者right_li来接受），然后反复进行下面的循环，直到第一次调用这个函数得到了属于自己的返回值，代码运行结束。
mid = n//2
# 接受归并排序后左边的有序列表
left_li = merge_sort(alist[:mid])
# 接受归并排序后右边的有序列表
right_li = merge_sort(alist[mid:])
left_pointer, right_pointer = 0, 0
result_list = []
# 循环条件满足时，说明左右两边的游标都没有走到列表的末尾
while left_pointer < len(left_li) and right_pointer < len(right_li):
if left_li[left_pointer] <= right_li[right_pointer]: # =号 是使排序稳定的作用
result_list.append(left_li[left_pointer])
left_pointer += 1
else:
result_list.append(right_li[right_pointer])
right_pointer += 1
# 退出循环后，让result_list需要和最后剩下的那个列表中的所有的元素都需要合并
result_list += left_li[left_pointer:]
result_list += right_li[right_pointer:]
return result_list
if __name__ == '__main__':
li = [17, 20, 93, 54, 77, 31, 44, 55, 226]
print(merge_sort(li))
# 时间复杂度：nlogn n每次合并的最大次数，logn为拆分的总次数。由于必须从中间拆分（没有特殊情况）：所以最优最差时间复杂度都是nlogn
# 稳定：因为合并的时候并没有改变相同元素的排列位置。
# 拓展： 时间最短，但是它要新建一个列表，所以在空间上是有额外的开销的。
# 归并排序和快速排序的区别:
# 后者是在列表本身上操作，前者需要新建列表来接受“确定值”。
# 后者理念是：将大的放“某一个数”右边，小的放左边，然后再以“某一个数”为分界点拆开，拆开后还按照“大的在右，小的在左”的思想去操作。前者的理念是：全都拆开，然后一点点的比较，然后放置新的列表中并返回。
补充：如何更好的理解递归?
- 1,递归需要终止条件
- 2,递归一般处理需要多次进行相同的操作。
- 3,递归一般需要返回值，如果没有返回值，它肯定也“改变”了什么。
- 本文仅服务作者本人。