冒泡排序（bubble sort）
思路
以升序为例：
从第一个数开始向后两两对比，将大的数一直向后移动，直至最大的数移到最后，再找第二大的数
最好情况：O(n)
一般情况：O(n^2)
最坏情况：O(n^2)
代码
import random
def bubble_sort(l):
for i in range(len(l) - 1):
exchange = False
for j in range(len(l) - 1 - i):
if l[j] > l[j + 1]:
l[j], l[j + 1] = l[j + 1], l[j]
exchange = True
if not exchange: # 如果一次循环中都没有交换，则说明已经排序完成，可以提前结束
break
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
bubble_sort(data)
print(data)
选择排序（selection sort）
思路
以升序为例：
从第一个位置开始向后寻找，找到最小的数，放在这个位置，之后向后移一个位置
时间复杂度
最好情况：O(n^2)
一般情况：O(n^2)
最坏情况：O(n^2)
代码
import random
def selection_sort(l):
for i in range(len(l) - 1):
min_num = i
for j in range(i + 1, len(l)):
if l[j] < l[min_num]:
min_num = j
if min_num != i:
l[i], l[min_num] = l[min_num], l[i]
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
selection_sort(data)
print(data)
插入排序（insertion sort）
思路
以升序为例：
将第一个数分为有序队列，后面为无序队列。从二个数开始，依次插入前面有序队列
时间复杂度
最好情况：O(n)
一般情况：O(n^2)
最坏情况：O(n^2)
代码
import random
def insertion_sort(l):
for i in range(1, len(l)):
tem = l[i]
j = i - 1
while j >= 0 and tem < l[j]:
l[j + 1] = l[j]
j -= 1
l[j + 1] = tem
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
insertion_sort(data)
print(data)
快速排序（quicksort）
Python 的 sort 时间复杂度为 O(nlogn)，但是因为是 C 写的，所以会快
思路
以升序为例：
从第一个数开始，将其他数分成两部分，小于这个数的放在左边，大于这个数的放在右边，分出的左右两边分别继续执行。
时间复杂度
最好情况：O(nlogn)
一般情况：O(nlogn)
最坏情况：O(n^2)
代码
import random
def quick_sort(l, left, right):
if left < right:
mid = partition(l, left, right)
quick_sort(l, left, mid - 1)
quick_sort(l, mid + 1, right)
def partition(l, left, right):
tem = l[left]
while left < right:
# 一次循环左右各移动一位
while left < right and l[right] > tem:
# 当前位不需要换位置，指针向内移动一位，直至遇到需要换位置的位
right -= 1
l[left] = l[right] # 将右边需要换位置的换到左边（取出的数之前的位置）
while left < right and l[left] < tem:
left += 1
l[right] = l[left]
l[left] = tem
return left
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
quick_sort(data, 0, len(data) - 1)
print(data)
堆排序（heapsort）
思路
以升序为例：
借助最大堆（大根堆）的特性，依次取出堆中最大的数（根结点的数），再对堆进行调整
时间复杂度
最好情况：O(nlogn)
一般情况：O(nlogn)
最坏情况：O(nlogn)
代码
import random
def sift(l, low, high):
i = low # 指向父节点
j = 2 * i + 1 # 指向左节点
tem = l[i] # 获取父节点的值
while j <= high: # 如果子节点在堆中（有子节点）
if j < high and l[j] < l[j + 1]: # 有右节点且比左节点大
j += 1 # 指向右节点
if tem < l[j]: # 如果根结点小于子节点中较大的那个
l[i] = l[j] # 将较大的值放入父节点
i = j # 指向下一层树
j = 2 * i + 1
else:
break
l[i] = tem # 将循环开始时的父节点数据写入
def heap_sort(l):
n = len(l)
for i in range(n // 2 - 1, -1, -1):
sift(l, i, n - 1)
# 堆建好了
for i in range(n - 1, -1, -1): # i 指向堆堆最后
l[0], l[i] = l[i], l[0] # 将当前最大数移到最后，最后的数移到根结点
sift(l, 0, i - 1)
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
heap_sort(data)
print(data)
归并排序（merge sort）
思路
以升序为例：
由于将两个有序列表合并比较简单，所以将列表无限分割成仅有一个元素的有序列表，之后再合并
时间复杂度
最好情况：O(nlogn)
一般情况：O(nlogn)
最坏情况：O(nlogn)
代码
import random
def merge_sort(l, low, high):
if low < high:
mid = (low + high) // 2
merge_sort(l, low, mid) # 前半部分迭代
merge_sort(l, mid + 1, high) # 后半部分迭代
merge(l, low, mid, high) # 调整
def merge(l, low, mid, high):
"""
用于将两个有序列表进行合并
"""
i = low # 指向左边有序列表第一个元素
j = mid + 1 # 指向右边有序列表第一个元素
tem_l = [] # 临时列表，用于存放合并后列表
while i <= mid and j <= high:
# 当左右列表中都有元素时
if l[i] <= l[j]:
tem_l.append(l[i])
i += 1
else:
tem_l.append(l[j])
j += 1
while i <= mid:
# 当左边列表中有元素时，直接将剩下的元素全部插入临时列表
tem_l.append(l[i])
i += 1
while j <= high:
# 当右边列表中有元素时，直接将剩下的元素全部插入临时列表
tem_l.append(l[j])
j += 1
# 用排序完成的元素替代未排序的元素
l[low:high + 1] = tem_l
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
merge_sort(data, 0, len(data) - 1)
print(data)
希尔排序（Shell's sort）
思路
以升序为例：
将元素分为n组，每一组进行插入排序，再将每组元素增加直至所有元素都在一组中
时间复杂度
O((1 + τ)n)
一般情况：O(1.3n)
代码
import random
def shell_sort(l):
gap = len(l) // 2
while gap > 0:
for i in range(gap, len(l)):
tem = l[i]
j = i - gap # 指向同组前一个元素
while j >= 0 and tem < l[j]: # 存在前一个元素并且比当前元素大
l[j + gap] = l[j] # 将前一个元素移到后面一位
j -= gap # 指向前一个元素
l[j + gap] = tem
gap //= 2
if __name__ == '__main__':
data = list(range(1000))
random.shuffle(data)
shell_sort(data)
print(data)