这是我参与「第三届青训营 -后端场」笔记创作活动的第4篇笔记。
本笔记总结了张云浩老师的「数据结构与算法」的课程内容（经典排序算法部分）。
1. 经典排序算法
插入排序 | 快速排序 | 堆排序
1.1 Insertion Sort 插入排序
原理：将元素不断插入已经排序好的array中
以上图为例：
-
起始只有一个元素 5 ，其本身是一个有序序列
-
后续元素插入有序序列中，即不断交换，直到找到第一个比其小的元素
Time complexity（时间复杂度）
Best Avg Worst O(n) O(n^2) O(n^2) 缺点：平均和最坏情况的时间复杂度高达O(n^2)
优点：最好情况时间复杂度为O(n)
代码（来自 pdqsort/sort.go at master · zhangyunhao116/pdqsort (github.com) 的实现）：
// insertionSort sorts v[begin:end) using insertion sort.
func insertionSort[T ordered](v []T) {
for cur := 1; cur < len(v); cur++ {
for j := cur; j > 0 && v[j] < v[j-1]; j-- {
v[j], v[j-1] = v[j-1], v[j]
}
}
}
1.2 Quick Sort 快速排序
可以在 visualising data structures and algorithms through animation - VisuAlgo 找到快排过程的可视化
原理：分治思想，不断分割序列直到序列整体有序
-
选定一个 pivot（轴点）
-
使用 pivot 分割序列，分成元素比 pivot 大 和元素比 pivot 小两个序列
Time complexity（时间复杂度）
Best Avg Worst O(n*logn) O(n*logn) O(n^2) 缺点：最坏情况的时间复杂度高达O(n^2)
优点：平均情况的时间复杂度为O(n*logn)
代码：
func partition(arr []int, low, high int) ([]int, int) {
pivot := arr[high]
i := low
for j := low; j < high; j++ {
if arr[j] < pivot {
arr[i], arr[j] = arr[j], arr[i]
i++
}
}
arr[i], arr[high] = arr[high], arr[i]
return arr, i
}
func quickSort(arr []int, low, high int) []int {
if low < high {
var p int
arr, p = partition(arr, low, high)
arr = quickSort(arr, low, p-1)
arr = quickSort(arr, p+1, high)
}
return arr
}
1.3 Heap Sort 堆排序
利用堆的性质形成的排序算法
-
构造一个大顶堆
-
将根节点（最大元素）交换到最后一个位置，调整整个堆，如此反复
Time complexity（时间复杂度）
Best Avg Worst O(n*logn) O(n*logn) O(n*logn) 缺点：最好情况的时间复杂度高达O(n*logn)
优点：最坏情况的时间复杂度为O(n*logn)
代码（来自 pdqsort/sort.go at master · zhangyunhao116/pdqsort (github.com) 的实现）：
// siftDown implements the heap property on v[lo:hi].
func siftDown[T ordered](v []T, node int) {
for {
child := 2*node + 1
if child >= len(v) {
break
}
if child+1 < len(v) && v[child] < v[child+1] {
child++
}
if v[node] >= v[child] {
return
}
v[node], v[child] = v[child], v[node]
node = child
}
}
func heapSort[T ordered](v []T) {
// Build heap with greatest element at top.
for i := (len(v) - 1) / 2; i >= 0; i-- {
siftDown(v, i)
}
// Pop elements into end of v.
for i := len(v) - 1; i >= 1; i-- {
v[0], v[i] = v[i], v[0]
siftDown(v[:i], 0)
}
}
经典算法理论印象
| Best | Avg | Worst | |
|---|---|---|---|
| InsertionSort | O(n) | O(n^2) | O(n^2) |
| QuickSort | O(n*logn) | O(n*logn) | O(n^2) |
| HeapSort | O(n*logn) | O(n*logn) | O(n*logn) |
- 插入排序平均和最坏情况时间复杂度都是O(n^2)，性能不好
- 快速排序整体性能处于中间层次
- 堆排序性能稳定，“众生平等”
实际场景 benchmark
根据序列元素排列情况划分：
- 完全随机的情况 (random)
- 有序/逆序的情况 (sorted/reverse)
- 元素重复度较高的情况 (mod8) 在此基础上，还需要根据序列长度来进行划分 (16/128/1024)
Benchmark-random
- 插入排序在短序列中速度最快
- 快速排序在其他情况中速度最快
- 堆排序速度与最快算法差距不大
Benchmark-sorted
- 插入排序在序列已经有序的情况下速度最快
实际场景 benchmark 结论
- 所有短序列和元素有序情况下，插入排序性能最好
- 在大部分的情况下，快速排序有较好的综合性能
- 几乎在任何情况下，堆排序的表现都比较稳定
以交通工具为例：
插入排序 ————————> 单车
快速排序 ————————> 汽车
堆排序 —————————> 地铁
我们在市内出行的时候，常常会选择多种交通工具来到达目的地，排序算法是否也可以如此呢？
| Best | Avg | Worst | |
|---|---|---|---|
| InsertionSort | O(n) | O(n^2) | O(n^2) |
| QuickSort | O(n*logn) | O(n*logn) | O(n^2) |
| HeapSort | O(n*logn) | O(n*logn) | O(n*logn) |
| ??? | O(n) | O(n*logn) | O(n*logn) |
我们如何结合已有的经典排序算法，打造一个性能更好的混合排序算法呢？
这些问题的答案，将再下一部分揭晓。
下篇链接：数据结构与算法（下） ｜ 青训营笔记 - 掘金 (juejin.cn)
