排序算法的稳定性：一个稳定的排序算法，如果两个等值键R和S在排序前后次序不变，称其是稳定的
例如排序之前的序列为：(4, 1) (3, 1) (3, 7)（5, 6）
(3, 1) (3, 7) (4, 1) (5, 6) 维持次序，稳定
(3, 7) (3, 1) (4, 1) (5, 6) 次序被改变，不稳定
1.冒泡排序
两两相邻记录的关键字，如果反序就交换，直到没有反序的记录为止。
# 直觉的写法，但实际不能算冒泡
def bubble_sort(alist):
for i in range(len(alist)-1): # 从第一个元素到倒数第二个元素
for j in range(i+1, len(alist)): # 如果a[i]比后面的元素更大，交换
if alist[i] > alist[j]:
alist[i], alist[j] = alist[j], aslit[i]
因为实际上每次固定的a[i]会和后面的所有元素都比较一遍，并不是冒泡中的比较两两相邻的关键字。
两两是相邻元素；如果有n个元素那就要比较n-1轮，每一轮都减少一次比较；从下往上两两比较，就像泡泡往上冒一样。
# 升序
def bubble_sort(alist):
n = len(alist)
for i in range(n-1): # 当前轮从a[i]开始，两两相邻比较，最后一轮从a[n-2]开始。a[:i]已经有序
for j in range(n-1, i, -1): # 从下向上冒
if alist[j] < alist[j-1]: # 如果后一个元素比前一个小，就交换
alist[j], alist[j-1] = alist[j-1], alist[j]
做一点优化
def bubble_sort_pro(alist):
n = len(alist)
for i in range(n-1):
count = 0
for j in range(n-1, i, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
count += 1
if count == 0: # 如果某一轮没有进行任何交换，说明整个数组已经有序了
return
2.选择排序
通过n-i次关键字之间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。1<=i<=n。
在未排序序列中找到最小（大）元素，放到已排序序列起始位置（一次交换）；
然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾（一次交换）；
以此类推，直到所有元素均排序完毕
选择排序的优点在于数据移动的操作：如果某个元素位于正确的最终位置上，它就不会被移动。所以至多需要交换 n-1 次（因为第一次就直接认为第一个元素是最小（大））。操作的是无序的那部分。
def selection_sort(alist):
n = len(alist)
for i in range(n-1): # 要找 n-1 轮最值，第一个首先认为是个最小（大）值
min_index = i # 记录当前的最小（大）位置
for j in range(i+1, n): # 遍历剩下无序部分的元素，找出最小的，再交换
if alist[j] < alist[min_index]:
min_index = j
if min_index != i:
alist[i], alist[min_index] = alist[min_index], alist[i]
3.直接插入排序
简单排序中性能最好的。将一个记录插入到一个已经排好序的有序表中。
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。所以过程中需反复把已经排序的元素向后挪。
操作的是有序的那部分。
def insert_sort(alist):
n = len(alist)
for i in range(1, n):
for j in range(i, 0, -1): # 待插入元素为a[i]，有序序列为a[:i]
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j] # a[i]从后往前比较，找到插入位置。就相当于一直交换。
优化
def insert_sort_pro(alist):
n = len(alist)
for i in range(1, n):
j = i
while j > 0:
# 寻找插入位置，只要没到位置，一直交换，最终插入
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
j -= 1
else: # 如果找到要插入的位置了就不用往前再看了，避免了多余的循环
break
4.希尔排序
时间复杂度降到O(nlogn)，对直接插入排序进行修改。
把记录按下标的一定增量（gap）分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个记录恰被分成一组，算法终止。
例如下图就是第一轮分了5组，第二轮分了2组
# 按gap进行插入排序
def shell_sort(alist):
n = len(alist)
gap = n // 2
while gap > 0:
for i in range(gap, n): # 从 0+gap 开始往后找元素往有序序列中插入，一直找到最后
j = i
while j >= gap and alist[j] < alist[j-gap]: # 每个子序列的j元素的前一个元素不再是j-1而是j-gap，因为要在a[j]属于的分组里做插入排序
alist[j-gap], alist[j] = alist[j], alist[j-gap]
j -= gap
gap //= 2 # 新步长
def shell_sort(alist):
n = len(alist)
gap = n // 2
while gap > 0:
for i in range(gap, n): # 待插元素从a[gap]到最后
for j in range(i, 0, -gap): # a[i]找插入位置，每次不再向前挪1而挪gap即可
if alist[j] < alist[j-gap]:
alist[j], alist[j-gap] = alist[j-gap], alist[j]
gap //= 2
5.堆排序
利用前一趟比较的结果，对选择排序进行改进。堆是具有以下性质的完全二叉树：每个节点的值都大于等于（小于等于）其左右孩子节点的值。
大顶堆 & 小顶堆
1. 将待排序的序列构造成一个大顶堆（或小顶堆）
2. 整个序列的最大值就是堆顶的根节点，将它移走（与堆数组的末尾元素交换，此时末尾元素就是最大值）。
3. 将剩余的n-1个序列重新构造成一个堆，重复上述步骤，获得升序序列。
升序排序，使用大顶堆。
堆具有的性质，如果从堆的根节点开始从1往后编号，则节点的值满足：
，n/2向下取整。
树节点编号从1开始而数组下标从0开始。统一成从0开始计数，父节点 i 的左右孩子节点在2i+1、2i+2，子节点 i 的父节点在 floor((i-1)/2)
def heapify(arr, lst, i):
"""维护最大堆，以i为根节点的子树，最后一个节点lst"""
largest = i
left, right = 2*i+1, 2*i+2
# 找到 i、i的左子树、i的右子树中的最大值
if left <= lst and arr[i] < arr[left]:
largest = left
if right <= lst and arr[largest] < arr[right]:
largest = right
# 如果这三个节点中最大的不是i，则最大节点的值和i的值交换
if largest != i:
arr[largest], arr[i] = arr[i], arr[largest]
heapify(arr, lst, largest) # 继续对largest节点递归维护堆。如果i是最大的元素，则函数结束
def heap_sort(arr):
n = len(arr)
for i in range(int((n-1-1)/2), -1, -1): # 从最后一个节点n-1的父节点开始往顶上，第一个要维护的子树根节点为 floor(((n-1)-1)/2)
heapify(arr, n-1, i)
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # 堆顶a[0] 和 当前堆的最后一个元素（如果认为每次都把排好的移除。实际就是arr[i]）交换
heapify(arr, i-1, 0) # 交换后要从顶向下维护堆，堆最后一个节点为下标为i-1
a = [3,4,1,2,9,5,6,8]
heap_sort(a)
print(a)
优化，把heapify函数中的尾部递归用迭代实现，效率更高
def heapify(arr, lst, i):
"""维护最大堆，以i为根节点的子树，最后一个节点lst"""
while True:
largest = i
left, right = 2*i+1, 2*i+2
# 找到 i、i的左子树、i的右子树中的最大值
if left <= lst and arr[i] < arr[left]:
largest = left
if right <= lst and arr[largest] < arr[right]:
largest = right
# 如果这三个节点中最大还是i，则函数结束
if largest == i:
break
arr[largest], arr[i] = arr[i], arr[largest] # 否则的把最大值换到当前根节点i上
i = largest # 继续下一轮，对当前的largest为根节点的子树进行维护
6.归并排序
分治思想，先递归分解数组，再合并数组。
将数组分解最小之后，把n个记录看成是n个有序的子序列，每个子序列长度为1。然后两两归并，得到ceil(n/2)个长度为2或者1的有序子序列，再两两归并...，如此重复直到得到长度为n的有序序列为止。
其中两两归并的基本思路是，比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
def merge_sort(alist):
if len(alist) <= 1:
return alist
# 二分分解
num = len(alist)//2
left = merge_sort(alist[:num])
right = merge_sort(alist[num:])
# 合并
return merge(left,right)
def merge(left, right):
'''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
#left与right的下标指针
l, r = 0, 0
result = []
while l<len(left) and r<len(right):
if left[l] < right[r]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
if l < len(left):
result += left[l:]
elif r < len(right):
result += right[r:]
return result
迭代实现，直接从下往上。
def merge_sort(alist):
if alist is None or len(alist) <= 1:
return alist
# 每次要合并的两组数组为 a[low, low+i]、a[low+i, low+2*i]
n = len(alist)
tmp = [0]*n # 建立临时数组
i = 1 # 步长，也就是合并后数组元素的一半。第一次合并后数组长度为2，所以i初始化为1
while i < n: # 最后一次合并之前i不超过n。例如考虑n=5的情况，i=1,2,4，最后i=4合并长度为4，1的两组后结束，下一轮i=8，超过n了
# 开始一趟，两两合并所有分组数组，每一趟都从头开始
low = 0
while low < n:
mid = low + i
high = min(low + 2*i, n) # 如果第二组越界了，high等于n即可。数组a[n]会越界，但a[:n]不会，等价于a[:]
if mid < high: # 只有存在第二组才需要merge。而第二组只要有元素，high一定大于等于mid+1
# merge
merge(alist, low, mid, high, tmp)
low += 2*i # 下两组的起始元素在上两组最后元素之后
i *= 2 # 每一趟合并全部结束后，下一趟步长翻倍
def merge(alist, low, mid, high, tmp):
"""这里merge要考虑分组数组长度为1的情况，还有high等于n的情况
所以还是用索引在长度上移动来遍历，比较不容易出错
"""
l, r, k = 0, 0, 0
len_l, len_r = len(alist[low: mid]), len(alist[mid: high]) # 两个数组的长度
while l < len_l and r < len_r: # 只要有一个数组遍历完了，补上没有遍历完的即可
if alist[low + l] < alist[mid + r]:
tmp[k] = alist[low + l]
k += 1
l += 1
else:
tmp[k] = alist[mid + r]
k += 1
r += 1
if l < len_l:
tmp[k: k + mid - (low + l)] = alist[low + l: mid]
alist[low: high] = tmp[: k + mid - (low + l)]
if r < len_r:
tmp[k: k + high - (mid + r)] = alist[mid + r: high]
alist[low: high] = tmp[: k + high - (mid + r)]
alist = [54,26,93,17,77,31,44,55,20]
merge_sort(alist)
print(alist)
7.快速排序
通过一趟排序将要排序的数据分割成独立的两部分（选择一个比较基准），其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行。
步骤：
挑一个元素作为基准，重排元素，比基准大的放基准后面，比基准小的放基准前面；
递归的把两个子序列进行用上述方法分别排序
def quick_sort(alist):
Qsort(alist, 0, len(alist)-1)
def Qsort(arr, low, high):
"""待排序数组arr, 起始位置low, 末尾位置high
"""
if low < high:
point = Partition(arr, low, high) # 根据基准点a[point]处理数组，小的放基准点左边大的放基准点右边
Qsort(arr, low, point-1)
Qsort(arr, point+1, high)
def Partition(arr, low, high):
# 起始元素为要寻找位置的基准元素，先把基准点的值拿出来，序列中始终就有一个多余的空位
point_value = arr[low] # 基准点初始化为起始元素
# 两个游标，low自左向右，high自右向左
while low < high:
while low < high and arr[high] >= point_value: # high游标自右向左找到比基准元素小的元素位置
high -= 1
arr[low], arr[high] = arr[high], arr[low] # 交换，把比基准点小的放前面
while low < high and arr[low] < point_value: # low游标自左向右找到比基准元素大的元素位置
low += 1
arr[high], arr[low] = arr[low], arr[high] # 交换，把比基准点大的放后面
alist[low] = point_value # 当low与high位置重合，这就是基准点在最终序列中的位置
return low
快速排序的优化
1. 优化基准点的选取，三数取中法，基准点选取三个数中间大小的那个，避免极端情况，提高性能。
def quick_sort(alist):
Qsort(alist, 0, len(alist)-1)
def Qsort(arr, low, high):
"""待排序数组arr, 起始位置low, 末尾位置high
"""
if low < high:
point = Partition(arr, low, high) # 根据基准点a[point]处理数组，小的放基准点左边大的放基准点右边
Qsort(arr, low, point-1)
Qsort(arr, point+1, high)
def Partition(arr, low, high):
# 令基准点介于a[low]和a[high]之间
mid = low + (high - low) // 2
if arr[mid] > arr[high]:
arr[mid], arr[high] = arr[high], arr[mid]
if arr[low] > arr[high]:
arr[low], arr[high] = arr[high], arr[low]
if arr[mid] > arr[low]:
arr[low], arr[mid] = arr[mid], arr[low]
point_value = arr[low] # 基准点
# 两个游标，low自左向右，high自右向左
while low < high:
while low < high and arr[high] >= point_value: # high游标自右向左找到比基准元素小的元素位置
high -= 1
arr[low], arr[high] = arr[high], arr[low] # 交换，把比基准点小的放前面
while low < high and arr[low] < point_value: # low游标自左向右找到比基准元素大的元素位置
low += 1
arr[high], arr[low] = arr[low], arr[high] # 交换，把比基准点大的放后面
alist[low] = point_value # 当low与high位置重合，这就是基准点在最终序列中的位置
return low
2. 优化不必要的交换，直接改成赋值就行了，因为先把基准元素拿出来了，始终有一个位置是空余的。
def quick_sort(alist):
Qsort(alist, 0, len(alist)-1)
def Qsort(arr, low, high):
"""待排序数组arr, 起始位置low, 末尾位置high
"""
if low < high:
point = Partition(arr, low, high) # 根据基准点a[point]处理数组，小的放基准点左边大的放基准点右边
Qsort(arr, low, point-1)
Qsort(arr, point+1, high)
def Partition(arr, low, high):
# 令基准点介于a[low]和a[high]之间
mid = low + (high - low) // 2
if arr[mid] > arr[high]:
arr[mid], arr[high] = arr[high], arr[mid]
if arr[low] > arr[high]:
arr[low], arr[high] = arr[high], arr[low]
if arr[mid] > arr[low]:
arr[low], arr[mid] = arr[mid], arr[low]
point_value = arr[low] # 基准点
# 两个游标，low自左向右，high自右向左
while low < high:
while low < high and arr[high] >= point_value: # high游标自右向左找到比基准元素小的元素位置
high -= 1
arr[low]= arr[high] # 赋值，把比基准点小的放前面
while low < high and arr[low] < point_value: # low游标自左向右找到比基准元素大的元素位置
low += 1
arr[high] = arr[low] # 交换，把比基准点大的放后面
alist[low] = point_value # 当low与high位置重合，这就是基准点在最终序列中的位置，填回去
return low
3. 优化小数组时的排序方案，数组长度小于7的时候用直接插入排序。
def InsertSort(alist, low, high): # 修改一下插入排序，只排序alist中low到high这一段
for i in range(low+1, high+1):
for j in range(i, low, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
def quick_sort(alist):
Qsort(alist, 0, len(alist)-1)
def Qsort(arr, low, high, MAX_LENGTH_INSERT_SORT=7):
"""待排序数组arr, 起始位置low, 末尾位置high
"""
if high - low > MAX_LENGTH_INSERT_SORT:
point = Partition(arr, low, high) # 根据基准点a[point]处理数组，小的放基准点左边大的放基准点右边
Qsort(arr, low, point-1)
Qsort(arr, point+1, high)
else: # 数组小的话就直接插入
InsertSort(arr, low, high)
def Partition(arr, low, high):
# 令基准点介于a[low]和a[high]之间
mid = low + (high - low) // 2
if arr[mid] > arr[high]:
arr[mid], arr[high] = arr[high], arr[mid]
if arr[low] > arr[high]:
arr[low], arr[high] = arr[high], arr[low]
if arr[mid] > arr[low]:
arr[low], arr[mid] = arr[mid], arr[low]
point_value = arr[low] # 基准点
# 两个游标，low自左向右，high自右向左
while low < high:
while low < high and arr[high] >= point_value: # high游标自右向左找到比基准元素小的元素位置
high -= 1
arr[low]= arr[high] # 赋值，把比基准点小的放前面
while low < high and arr[low] < point_value: # low游标自左向右找到比基准元素大的元素位置
low += 1
arr[high] = arr[low] # 交换，把比基准点大的放后面
alist[low] = point_value # 当low与high位置重合，这就是基准点在最终序列中的位置，填回去
return low
4. 优化递归操作，只要有可能，就把递归写成尾递归（函数中的递归形式出现在末尾），能够提高运行效率。尾递归可以比较容易的写成迭代。
def InsertSort(alist, low, high): # 修改一下插入排序，只排序alist中low到high这一段
for i in range(low+1, high+1):
for j in range(i, low, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
def quick_sort(alist):
Qsort(alist, 0, len(alist)-1)
def Qsort(arr, low, high, MAX_LENGTH_INSERT_SORT=7):
"""待排序数组arr, 起始位置low, 末尾位置high
"""
if high - low > MAX_LENGTH_INSERT_SORT:
while low < high:
point = Partition(arr, low, high) # 根据基准点a[point]处理数组，小的放基准点左边大的放基准点右边
Qsort(arr, low, point-1)
# 现在 low 已经没用了，后半部分的递归是point+1到high，如果令low=point+1，则可以在用循环在下一轮实现point+1到high的递归
low = point + 1 # 把尾递归写成while循环
else: # 数组小的话就直接插入
InsertSort(arr, low, high)
def Partition(arr, low, high):
# 令基准点介于a[low]和a[high]之间
mid = low + (high - low) // 2
if arr[mid] > arr[high]:
arr[mid], arr[high] = arr[high], arr[mid]
if arr[low] > arr[high]:
arr[low], arr[high] = arr[high], arr[low]
if arr[mid] > arr[low]:
arr[low], arr[mid] = arr[mid], arr[low]
point_value = arr[low] # 基准点
# 两个游标，low自左向右，high自右向左
while low < high:
while low < high and arr[high] >= point_value: # high游标自右向左找到比基准元素小的元素位置
high -= 1
arr[low]= arr[high] # 赋值，把比基准点小的放前面
while low < high and arr[low] < point_value: # low游标自左向右找到比基准元素大的元素位置
low += 1
arr[high] = arr[low] # 交换，把比基准点大的放后面
alist[low] = point_value # 当low与high位置重合，这就是基准点在最终序列中的位置，填回去
return low
进一步地，要充分发挥递归的优势，加一个判断，令长度大的那部分用循环代替尾递归
def InsertSort(alist, low, high): # 修改一下插入排序，只排序alist中low到high这一段
for i in range(low+1, high+1):
for j in range(i, low, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
def quick_sort(alist):
Qsort(alist, 0, len(alist)-1)
def Qsort(arr, low, high, MAX_LENGTH_INSERT_SORT=7):
"""待排序数组arr, 起始位置low, 末尾位置high
"""
if high - low > MAX_LENGTH_INSERT_SORT:
while low < high:
point = Partition(arr, low, high) # 根据基准点a[point]处理数组，小的放基准点左边大的放基准点右边
if point - low < high - point: # 后半数组长度大
Qsort(arr, low, point - 1)
# 现在 low 已经没用了，后半部分的递归是point+1到high，如果令low=point+1，则可以在用循环在下一轮实现point+1到high的递归
low = point + 1 # 把尾递归写成while循环
else:
Qsort(arr, point + 1, high) # 现在high已经没用了
high = point - 1
else: # 数组小的话就直接插入
InsertSort(arr, low, high)
def Partition(arr, low, high):
# 令基准点介于a[low]和a[high]之间
mid = low + (high - low) // 2
if arr[mid] > arr[high]:
arr[mid], arr[high] = arr[high], arr[mid]
if arr[low] > arr[high]:
arr[low], arr[high] = arr[high], arr[low]
if arr[mid] > arr[low]:
arr[low], arr[mid] = arr[mid], arr[low]
point_value = arr[low] # 基准点
# 两个游标，low自左向右，high自右向左
while low < high:
while low < high and arr[high] >= point_value: # high游标自右向左找到比基准元素小的元素位置
high -= 1
arr[low]= arr[high] # 赋值，把比基准点小的放前面
while low < high and arr[low] < point_value: # low游标自左向右找到比基准元素大的元素位置
low += 1
arr[high] = arr[low] # 交换，把比基准点大的放后面
alist[low] = point_value # 当low与high位置重合，这就是基准点在最终序列中的位置，填回去
return low