文章目录
排序算法总览
比较类排序算法
交换排序
一. 冒泡排序
二. 快速排序
三. 插入排序
四. 希尔排序
五. 选择排序
六. 堆排序
七. 归并排序
非比较类排序算法
一. 计数排序
二. 桶排序
三. 基数排序
排序算法总览
十大排序算法可以分为比较类排序以及非比较类排序。
- 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O ( n l o g n ) O(nlogn)O(nlogn)，因此也称为非线性时间比较类排序。
- 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张表格概括：
排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 排序方式 | 稳定性 |
冒泡排序 | O ( n 2 ) O(n^2)O(n2) | O ( n ) O(n)O(n) | O ( n 2 ) O(n^2)O(n2) | O ( 1 ) O(1)O(1) | In-place | 稳定 |
选择排序 | O ( n 2 ) O(n^2)O(n2) | O ( n 2 ) O(n^2)O(n2) | O ( n 2 ) O(n^2)O(n2) | O ( 1 ) O(1)O(1) | In-place | 不稳定 |
插入排序 | O ( n 2 ) O(n^2)O(n2) | O ( n ) O(n)O(n) | O ( n 2 ) O(n^2)O(n2) | O ( 1 ) O(1)O(1) | In- place | 稳定 |
希尔排序 | O ( n l o g n ) O(n log n)O(nlogn) | O ( n l o g 2 n ) O(n log^2 n)O(nlog2n) | O ( n l o g 2 n ) O(n log^2n)O(nlog2n) | O ( 1 ) O(1)O(1) | In- place | 不稳定 |
归并排序 | O ( n l o g n ) O(n log n)O(nlogn) | O ( n l o g n ) O(nlogn)O(nlogn) | O ( n l o g n ) O(nlogn)O(nlogn) | O ( n ) O(n)O(n) | Out-place | 稳定 |
快速排序 | O ( n l o g n ) O(n log n)O(nlogn) | O ( n l o g n ) O(n log n)O(nlogn) | O ( n 2 ) O(n^2)O(n2) | O ( l o g n ) O(log n)O(logn) | In-place | 不稳定 |
堆排序 | O ( n l o g n ) O(n log n)O(nlogn) | O ( n l o g n ) O(nlogn)O(nlogn) | O ( n l o g n ) O(nlogn)O(nlogn) | O ( 1 ) O(1)O(1) | In-place | 不稳定 |
计数排序 | O ( n + k ) O(n + k)O(n+k) | O ( n + k ) O(n + k)O(n+k) | O ( n + k ) O(n + k)O(n+k) | O ( k ) O(k)O(k) | Out-place | 稳定 |
桶排序 | O ( n + k ) O(n + k)O(n+k) | O ( n + k ) O(n + k)O(n+k) | O ( n 2 ) O(n^2)O(n2) | O ( n + k ) O(n + k)O(n+k) | Out- -place | 稳定 |
基数排序 | O ( n k ) O(nk)O(nk) | O ( n k ) O(nk)O(nk) | O ( n k ) O(nk)O(nk) | O ( n + k ) O(n + k)O(n+k) | Out-place | 稳定 |
比较类排序算法
交换排序
一. 冒泡排序
算法思想
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。
算法步骤
1.比较相邻的元素。如果第一个元素比第二个元素大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
注：原始的冒泡是从后往前的
动图演示
代码实现
def Bubble_Sort(arr):
for i in range(len(arr)-1):
# 如果某一趟排序并没有发生交换,那么可以认为数组有序,终止排序即可。
flag = False
for j in range(len(arr)-i-1):
if arr[j] > arr[j+1]:
flag = True
arr[j], arr[j+1] = arr[j+1], arr[j]
if flag == False:
break二. 快速排序
算法思想
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 O ( n l o g n ) Ο(nlogn)O(nlogn) 次比较。在最坏状况下则需要 O ( n 2 ) Ο(n^2)O(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 O ( n l o g n ) Ο(nlogn)O(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。
算法步骤
1.从数列中挑出一个元素，称为 “基准”（pivot）;
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
动图演示
代码实现
import random
# 随机选择基准
def random_selection(arr, l, r):
pos = random.randint(l, r)
arr[pos], arr[r] = arr[r], arr[pos]
# 根据基准对数组进行划分
def partition(arr, l, r):
pivot = arr[r]
i = l - 1
for j in range(l, r):
if arr[j] <= pivot:
i += 1
arr[i], arr[j] = arr[j], arr[i]
arr[r], arr[i+1] = arr[i+1], arr[r]
return i + 1
# 随机选择基准后并划分
def random_partition(arr, l, r):
random_selection(arr, l, r)
pos = partition(arr, l, r)
if pos - l >= 2:
random_partition(arr, l, pos-1)
if r - pos >= 2:
random_partition(arr, pos+1, r)
def Quick_Sort(arr):
random_partition(arr, 0, len(arr)-1)三. 插入排序
算法思想
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。就像我们斗地主时，抽牌阶段会把抽到的牌插入到相应的位置中去，使手上的牌有序。
插入排序有个小优化叫做折半插入，就是往前寻找插入位置时，因为前面的数组全部有序，因此我们用二分查找法来寻找插入位置。
算法步骤
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面，保持相应顺序不变，插入排序是一个稳定的排序算法。）
动图演示
代码实现
def insertionSort(arr):
for i in range(1,len(arr)):
pos, insert_num = 0, arr[i]
for j in range(i-1,-1,-1):
if insert_num < arr[j]:
arr[j+1] = arr[j]
if insert_num >= arr[j]:
arr[j+1] = insert_num
pos = j+1
break
if pos == 0:
arr[0] = insert_num四. 希尔排序
算法思想
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
算法步骤
1.选择一个增量序列 t 1 ， t 2 ， … … ， t k t_1，t_2，……，t_kt1，t2，……，tk，其中 t i > t j t_i > t_jti>tj, t k = 1 t_k = 1tk=1；
2.按增量序列个数 k kk，对序列进行 k kk 趟排序；
3.每趟排序，根据对应的增量 t i t_iti，将待排序列分割成若干长度为 m mm 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 11 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
动图演示
代码实现
只需要将插入排序稍微修改一下，就可以得到希尔排序。
def gap(length):
ans = [length//2]
while ans[-1] > 1:
ans.append(ans[-1]//2)
return ans
def insertionSort(arr, step):
for i in range(step, len(arr), step):
pos, insert_num = 0, arr[i]
for j in range(i - step, -step, -step):
if insert_num < arr[j]:
arr[j+step] = arr[j]
if insert_num >= arr[j]:
arr[j+step] = insert_num
pos = j+1
break
if pos == 0:
arr[0] = insert_num
def ShellSort(arr):
steps = gap(len(arr))
for step in steps:
insertionSort(arr, step)五. 选择排序
算法思想
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
算法步骤
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
动图演示
代码实现
def SelectSort(arr):
for i in range(len(arr)-1):
min_val, pos = arr[i], i
for j in range(i+1, len(arr)):
if arr[j] < min_val:
min_val, pos = arr[j], j
arr[i], arr[pos] = arr[pos], arr[i]六. 堆排序
算法思想
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：
- 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列
- 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列
堆排序的平均时间复杂度为 Ο(nlogn)，利用堆的特性，其实我们可以很方便的得到一个未排序数组中的Top K元素。
算法步骤
1.创建一个堆 H[0……n-1]；
2.把堆首（最大值）和堆尾互换；
3.把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置
4.重复步骤 2，直到堆的尺寸为 1。
动图演示
代码实现
def insert(arr, index):
current = index
while current > 0:
parent = (current - 1) // 2
if arr[current] > arr[parent]:
arr[parent], arr[current] = arr[current], arr[parent]
else:
break
current = parent
def shift_down(arr, index):
current = 0
while current <= (index-1) // 2:
left_child = 2 * current + 1
right_child = 2 * current + 2
# 无右孩子
if right_child > index:
if arr[left_child] > arr[current]:
arr[left_child], arr[current] = arr[current], arr[left_child]
current = left_child
else:
break
else:
if arr[current] > max(arr[left_child], arr[right_child]):
break
else:
if arr[left_child] == max(arr[left_child], arr[right_child]):
arr[left_child], arr[current] = arr[current], arr[left_child]
current = left_child
else:
arr[right_child], arr[current] = arr[current], arr[right_child]
current = right_child
def HeapSort(arr):
# 构建初始堆
for index in range(len(arr)):
insert(arr, index)
for index in range(len(arr)-1,0,-1):
arr[index], arr[0] = arr[0], arr[index]
if index > 1:
shift_down(arr, index-1)七. 归并排序
算法思想
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：
自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
自下而上的迭代；
算法步骤
二路归并排序：
1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
2.设定两个指针，最初位置分别为两个已经排序序列的起始位置；
3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
4.重复步骤 3 直到某一指针达到序列尾；
5.将另一序列剩下的所有元素直接复制到合并序列尾。
动图演示
代码实现
def MergeSort(arr, l, r):
if r - l > 1:
mid = (l + r) // 2
MergeSort(arr, l, mid)
MergeSort(arr, mid+1, r)
temp = []
i, j = l, mid+1
while i <= mid and j <= r:
if arr[i] < arr[j]:
temp.append(arr[i])
i += 1
else:
temp.append(arr[j])
j += 1
while i <= mid:
temp.append(arr[i])
i += 1
while j <= r:
temp.append(arr[j])
j += 1
for index in range(l, r+1):
arr[index] = temp[index-l]
elif r - l == 1 and arr[l] > arr[r]:
arr[l], arr[r] = arr[r], arr[l]多路归并排序的思路参考上述代码，无非就是多了几个有序数组合并而已。
非比较类排序算法
一. 计数排序
算法思想
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。
由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。
通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。
算法步骤
1.找出待排序的数组中最大和最小的元素
2.统计数组中每个值为i的元素出现的次数，存入数组C的第 i 项
3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
4.反向填充目标数组：将每个元素 i 放在新数组的第C(i)项，每放一个元素就将C(i)减去1
动图演示
代码实现
def CountingSort(arr, maxValue):
bucketLen = maxValue+1
bucket = [0]*bucketLen
sortedIndex =0
arrLen = len(arr)
for i in range(arrLen):
if not bucket[arr[i]]:
bucket[arr[i]]=0
bucket[arr[i]]+=1
for j in range(bucketLen):
while bucket[j]>0:
arr[sortedIndex] = j
sortedIndex+=1
bucket[j]-=1
return arr二. 桶排序
算法思想
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
在额外空间充足的情况下，尽量增大桶的数量
使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。
1.什么时候最快
当输入的数据可以均匀的分配到每一个桶中。
2.什么时候最慢
当输入的数据被分配到了同一个桶中。
示意图
元素分布在桶中：
然后，元素在每个桶中排序：
代码实现
def bucket_sort(arr, bucket_size):
min_val = min(arr)
max_val = max(arr)
bucket_count = ((max_val - min_val) // bucket_size) + 1
buckets = [[] for _ in range(bucket_count)]
for data in arr:
index = ((data - min_val) // bucket_size)
buckets[index].append(data)
for i in range(bucket_count):
buckets[i].sort()
new_arr = []
for i in range(bucket_count):
for j in range(len(buckets[i])):
new_arr.append(buckets[i][j])
return new_arr三. 基数排序
算法思想
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
基数排序 vs 计数排序 vs 桶排序
基数排序有两种方法：
这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：
基数排序：根据键值的每位数字来分配桶；
计数排序：每个桶只存储单一键值；
桶排序：每个桶存储一定范围的数值；
动图演示
代码实现
def radix_sort(s):
i = 0
max_num = max(s)
j = len(str(max_num))
while i < j:
bucket_list =[[] for _ in range(10)]
for x in s:
bucket_list[int(x / (10**i)) % 10].append(x)
print(bucket_list)
s.clear()
for x in bucket_list:
for y in x:
s.append(y)
i += 1
