快速排序
快速排序是一種分治策略的排序演算法,是由英國電腦科學家Tony Hoare
發明的, 該演算法被髮布在1961
年的Communications of the ACM 國際計算機學會月刊
。
注:ACM = Association for Computing Machinery
,國際計算機學會,世界性的計算機從業員專業組織,創立於1947年,是世界上第一個科學性及教育性計算機學會。
快速排序是對氣泡排序的一種改進,也屬於交換類的排序演算法。
一、演算法介紹
快速排序通過一趟排序將要排序的資料分割成獨立的兩部分,其中一部分的所有資料都比另外一部分的所有資料都要小,然後再按此方法對這兩部分資料分別進行快速排序,整個排序過程可以遞迴進行,以此達到整個資料變成有序序列。
步驟如下:
- 先從數列中取出一個數作為基準數。一般取第一個數。
- 分割槽過程,將比這個數大的數全放到它的右邊,小於或等於它的數全放到它的左邊。
- 再對左右區間重複第二步,直到各區間只有一個數。
舉一個例子:5 9 1 6 8 14 6 49 25 4 6 3
。
一般取第一個數 5 作為基準,從它左邊和最後一個數使用[]進行標誌,
如果左邊的數比基準數大,那麼該數要往右邊扔,也就是兩個[]數交換,這樣大於它的數就在右邊了,然後右邊[]數左移,否則左邊[]數右移。
5 [9] 1 6 8 14 6 49 25 4 6 [3] 因為 9 > 5,兩個[]交換位置後,右邊[]左移
5 [3] 1 6 8 14 6 49 25 4 [6] 9 因為 3 !> 5,兩個[]不需要交換,左邊[]右移
5 3 [1] 6 8 14 6 49 25 4 [6] 9 因為 1 !> 5,兩個[]不需要交換,左邊[]右移
5 3 1 [6] 8 14 6 49 25 4 [6] 9 因為 6 > 5,兩個[]交換位置後,右邊[]左移
5 3 1 [6] 8 14 6 49 25 [4] 6 9 因為 6 > 5,兩個[]交換位置後,右邊[]左移
5 3 1 [4] 8 14 6 49 [25] 6 6 9 因為 4 !> 5,兩個[]不需要交換,左邊[]右移
5 3 1 4 [8] 14 6 49 [25] 6 6 9 因為 8 > 5,兩個[]交換位置後,右邊[]左移
5 3 1 4 [25] 14 6 [49] 8 6 6 9 因為 25 > 5,兩個[]交換位置後,右邊[]左移
5 3 1 4 [49] 14 [6] 25 8 6 6 9 因為 49 > 5,兩個[]交換位置後,右邊[]左移
5 3 1 4 [6] [14] 49 25 8 6 6 9 因為 6 > 5,兩個[]交換位置後,右邊[]左移
5 3 1 4 [14] 6 49 25 8 6 6 9 兩個[]已經彙總,因為 14 > 5,所以 5 和[]之前的數 4 交換位置
第一輪切分結果:4 3 1 5 14 6 49 25 8 6 6 9
現在第一輪快速排序已經將數列分成兩個部分:
4 3 1 和 14 6 49 25 8 6 6 9
左邊的數列都小於 5,右邊的數列都大於 5。
使用遞迴分別對兩個數列進行快速排序。
快速排序主要靠基準數進行切分,將數列分成兩部分,一部分比基準數都小,一部分比基準數都大。
在最好情況下,每一輪都能平均切分,這樣遍歷元素只要n/2
次就可以把數列分成兩部分,每一輪的時間複雜度都是:O(n)
。因為問題規模每次被折半,折半的數列繼續遞迴進行切分,也就是總的時間複雜度計算公式為:T(n) = 2*T(n/2) + O(n)
。按照主定理公式計算,我們可以知道時間複雜度為:O(nlogn)
,當然我們可以來具體計算一下:
我們來分析最好情況,每次切分遍歷元素的次數為 n/2
T(n) = 2*T(n/2) + n/2
T(n/2) = 2*T(n/4) + n/4
T(n/4) = 2*T(n/8) + n/8
T(n/8) = 2*T(n/16) + n/16
...
T(4) = 2*T(2) + 4
T(2) = 2*T(1) + 2
T(1) = 1
進行合併也就是:
T(n) = 2*T(n/2) + n/2
= 2^2*T(n/4)+ n/2 + n/2
= 2^3*T(n/8) + n/2 + n/2 + n/2
= 2^4*T(n/16) + n/2 + n/2 + n/2 + n/2
= ...
= 2^logn*T(1) + logn * n/2
= 2^logn + 1/2*nlogn
= n + 1/2*nlogn
因為當問題規模 n 趨於無窮大時 nlogn 比 n 大,所以 T(n) = O(nlogn)。
最好時間複雜度為:O(nlogn)。
最差的情況下,每次都不能平均地切分,每次切分都因為基準數是最大的或者最小的,不能分成兩個數列,這樣時間複雜度變為了T(n) = T(n-1) + O(n)
,按照主定理計算可以知道時間複雜度為:O(n^2)
,我們可以來實際計算一下:
我們來分析最差情況,每次切分遍歷元素的次數為 n
T(n) = T(n-1) + n
= T(n-2) + n-1 + n
= T(n-3) + n-2 + n-1 + n
= ...
= T(1) + 2 +3 + ... + n-2 + n-1 + n
= O(n^2)
最差時間複雜度為:O(n^2)。
根據熵的概念,數量越大,隨機性越高,越自發無序,所以待排序資料規模非常大時,出現最差情況的情形較少。在綜合情況下,快速排序的平均時間複雜度為:O(nlogn)
。對比之前介紹的排序演算法,快速排序比那些動不動就是平方級別的初級排序演算法更佳。
切分的結果極大地影響快速排序的效能,為了避免切分不均勻情況的發生,有幾種方法改進:
- 每次進行快速排序切分時,先將數列隨機打亂,再進行切分,這樣隨機加了個震盪,減少不均勻的情況。當然,也可以隨機選擇一個基準數,而不是選第一個數。
- 每次取數列頭部,中部,尾部三個數,取三個數的中位數為基準數進行切分。
方法 1 相對好,而方法 2 引入了額外的比較操作,一般情況下我們可以隨機選擇一個基準數。
快速排序使用原地排序,儲存空間複雜度為:O(1)
。而因為遞迴棧的影響,遞迴的程式棧開闢的層數範圍在logn~n
,所以遞迴棧的空間複雜度為:O(logn)~log(n)
,最壞為:log(n)
,當元素較多時,程式棧可能溢位。通過改進演算法,使用偽尾遞迴進行優化,遞迴棧的空間複雜度可以減小到O(logn)
,可以見下面演算法優化。
快速排序是不穩定的,因為切分過程中進行了交換,相同值的元素可能發生位置變化。
二、演算法實現
package main
import "fmt"
// 普通快速排序
func QuickSort(array []int, begin, end int) {
if begin < end {
// 進行切分
loc := partition(array, begin, end)
// 對左部分進行快排
QuickSort(array, begin, loc-1)
// 對右部分進行快排
QuickSort(array, loc+1, end)
}
}
// 切分函式,並返回切分元素的下標
func partition(array []int, begin, end int) int {
i := begin + 1 // 將array[begin]作為基準數,因此從array[begin+1]開始與基準數比較!
j := end // array[end]是陣列的最後一位
// 沒重合之前
for i < j {
if array[i] > array[begin] {
array[i], array[j] = array[j], array[i] // 交換
j--
} else {
i++
}
}
/* 跳出while迴圈後,i = j。
* 此時陣列被分割成兩個部分 --> array[begin+1] ~ array[i-1] < array[begin]
* --> array[i+1] ~ array[end] > array[begin]
* 這個時候將陣列array分成兩個部分,再將array[i]與array[begin]進行比較,決定array[i]的位置。
* 最後將array[i]與array[begin]交換,進行兩個分割部分的排序!以此類推,直到最後i = j不滿足條件就退出!
*/
if array[i] >= array[begin] { // 這裡必須要取等“>=”,否則陣列元素由相同的值組成時,會出現錯誤!
i--
}
array[begin], array[i] = array[i], array[begin]
return i
}
func main() {
list := []int{5}
QuickSort(list, 0, len(list)-1)
fmt.Println(list)
list1 := []int{5, 9}
QuickSort(list1, 0, len(list1)-1)
fmt.Println(list1)
list2 := []int{5, 9, 1}
QuickSort(list2, 0, len(list2)-1)
fmt.Println(list2)
list3 := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
QuickSort(list3, 0, len(list3)-1)
fmt.Println(list3)
}
輸出:
[5]
[5 9]
[1 5 9]
[1 3 4 5 6 6 6 8 9 14 25 49]
示例圖:
快速排序,每一次切分都維護兩個下標,進行推進,最後將數列分成兩部分。
三、演算法改進
快速排序可以繼續進行演算法改進。
- 在小規模陣列的情況下,直接插入排序的效率最好,當快速排序遞迴部分進入小陣列範圍,可以切換成直接插入排序。
- 排序數列可能存在大量重複值,使用三向切分快速排序,將陣列分成三部分,大於基準數,等於基準數,小於基準數,這個時候需要維護三個下標。
- 使用偽尾遞迴減少程式棧空間佔用,使得棧空間複雜度從
O(logn)~log(n)
變為:O(logn)
。
3.1 改進:小規模陣列使用直接插入排序
func QuickSort1(array []int, begin, end int) {
if begin < end {
// 當陣列小於 4 時使用直接插入排序
if end-begin <= 4 {
InsertSort(array[begin : end+1])
return
}
// 進行切分
loc := partition(array, begin, end)
// 對左部分進行快排
QuickSort1(array, begin, loc-1)
// 對右部分進行快排
QuickSort1(array, loc+1, end)
}
}
直接插入排序在小規模陣列下效率極好,我們只需將end-begin <= 4
的遞迴部分換成直接插入排序,這部分表示小陣列排序。
3.2 改進:三向切分
package main
import "fmt"
// 三切分的快速排序
func QuickSort2(array []int, begin, end int) {
if begin < end {
// 三向切分函式,返回左邊和右邊下標
lt, gt := partition3(array, begin, end)
// 從lt到gt的部分是三切分的中間數列
// 左邊三向快排
QuickSort2(array, begin, lt-1)
// 右邊三向快排
QuickSort2(array, gt+1, end)
}
}
// 切分函式,並返回切分元素的下標
func partition3(array []int, begin, end int) (int, int) {
lt := begin // 左下標從第一位開始
gt := end // 右下標是陣列的最後一位
i := begin + 1 // 中間下標,從第二位開始
v := array[begin] // 基準數
// 以中間座標為準
for i <= gt {
if array[i] > v { // 大於基準數,那麼交換,右指標左移
array[i], array[gt] = array[gt], array[i]
gt--
} else if array[i] < v { // 小於基準數,那麼交換,左指標右移
array[i], array[lt] = array[lt], array[i]
lt++
i++
} else {
i++
}
}
return lt, gt
}
演示:
數列:4 8 2 4 4 4 7 9,基準數為 4
[4] [8] 2 4 4 4 7 [9] 從中間[]開始:8 > 4,中右[]進行交換,右邊[]左移
[4] [9] 2 4 4 4 [7] 8 從中間[]開始:9 > 4,中右[]進行交換,右邊[]左移
[4] [7] 2 4 4 [4] 9 8 從中間[]開始:7 > 4,中右[]進行交換,右邊[]左移
[4] [4] 2 4 [4] 7 9 8 從中間[]開始:4 == 4,不需要交換,中間[]右移
[4] 4 [2] 4 [4] 7 9 8 從中間[]開始:2 < 4,中左[]需要交換,中間和左邊[]右移
2 [4] 4 [4] [4] 7 9 8 從中間[]開始:4 == 4,不需要交換,中間[]右移
2 [4] 4 4 [[4]] 7 9 8 從中間[]開始:4 == 4,不需要交換,中間[]右移,因為已經重疊了
第一輪結果:2 4 4 4 4 7 9 8
分成三個數列:
2
4 4 4 4 (元素相同的會聚集在中間數列)
7 9 8
接著對第一個和最後一個數列進行遞迴即可。
示例圖:
三切分,把小於基準數的扔到左邊,大於基準數的扔到右邊,相同的元素會進行聚集。
如果存在大量重複元素,排序速度將極大提高,將會是線性時間,因為相同的元素將會聚集在中間,這些元素不再進入下一個遞迴迭代。
三向切分主要來自荷蘭國旗三色問題,該問題由Dijkstra
提出。
假設有一條繩子,上面有紅、白、藍三種顏色的旗子,起初繩子上的旗子顏色並沒有順序,您希望將之分類,並排列為藍、白、紅的順序,要如何移動次數才會最少,注意您只能在繩子上進行這個動作,而且一次只能調換兩個旗子。
可以看到,上面的解答相當於使用三向切分一次,只要我們將白色旗子的值設定為100
,藍色的旗子值設定為0
,紅色旗子值設定為200
,以100
作為基準數,第一次三向切分後三種顏色的旗就排好了,因為藍(0)白(100)紅(200)
。
注:艾茲格·W·迪科斯徹(Edsger Wybe Dijkstra
,1930年5月11日~2002年8月6日),荷蘭人,電腦科學家,曾獲圖靈獎。
3.3 改進:偽尾遞迴優化
// 偽尾遞迴快速排序
func QuickSort3(array []int, begin, end int) {
for begin < end {
// 進行切分
loc := partition(array, begin, end)
// 那邊元素少先排哪邊
if loc-begin < end-loc {
// 先排左邊
QuickSort3(array, begin, loc-1)
begin = loc + 1
} else {
// 先排右邊
QuickSort3(array, loc+1, end)
end = loc - 1
}
}
}
很多人以為這樣子是尾遞迴。其實這樣的快排寫法是偽裝的尾遞迴,不是真正的尾遞迴,因為有for
迴圈,不是直接return QuickSort
,遞迴還是不斷地壓棧,棧的層次仍然不斷地增長。
但是,因為先讓規模小的部分排序,棧的深度大大減少,程式棧最深不會超過logn
層,這樣堆疊最壞空間複雜度從O(n)
降為O(logn)
。
這種優化也是一種很好的優化,因為棧的層數減少了,對於排序十億個整數,也只要:log(100 0000 0000)=29.897
,佔用的堆疊層數最多30
層,比不進行優化,可能出現的O(n)
常數層好很多。
四、補充:非遞迴寫法
非遞迴寫法僅僅是將之前的遞迴棧轉化為自己維持的手工棧。
// 非遞迴快速排序
func QuickSort5(array []int) {
// 人工棧
helpStack := new(LinkStack)
// 第一次初始化棧,推入下標0,len(array)-1,表示第一次對全陣列範圍切分
helpStack.Push(len(array) - 1)
helpStack.Push(0)
// 棧非空證明存在未排序的部分
for !helpStack.IsEmpty() {
// 出棧,對begin-end範圍進行切分排序
begin := helpStack.Pop() // 範圍區間左邊
end := helpStack.Pop() // 範圍
// 進行切分
loc := partition(array, begin, end)
// 右邊範圍入棧
if loc+1 < end {
helpStack.Push(end)
helpStack.Push(loc + 1)
}
// 左邊返回入棧
if begin < loc-1 {
helpStack.Push(loc - 1)
helpStack.Push(begin)
}
}
}
本來需要進行遞迴的陣列範圍begin,end
,不使用遞迴,依次推入自己的人工棧,然後迴圈對人工棧進行處理。
我們可以看到沒有遞迴,程式棧空間複雜度變為了:O(1)
,但額外的儲存空間產生了。
輔助人工棧結構helpStack
佔用了額外的空間,儲存空間由原地排序的O(1)
變成了O(logn)~log(n)
。
我們可以參考上面的偽尾遞迴版本,繼續優化非遞迴版本,先讓短一點的範圍入棧,這樣儲存複雜度可以變為:O(logn)
。如:
// 非遞迴快速排序優化
func QuickSort6(array []int) {
// 人工棧
helpStack := new(LinkStack)
// 第一次初始化棧,推入下標0,len(array)-1,表示第一次對全陣列範圍切分
helpStack.Push(len(array) - 1)
helpStack.Push(0)
// 棧非空證明存在未排序的部分
for !helpStack.IsEmpty() {
// 出棧,對begin-end範圍進行切分排序
begin := helpStack.Pop() // 範圍區間左邊
end := helpStack.Pop() // 範圍
// 進行切分
loc := partition(array, begin, end)
// 切分後右邊範圍大小
rSize := -1
// 切分後左邊範圍大小
lSize := -1
// 右邊範圍入棧
if loc+1 < end {
rSize = end - (loc + 1)
}
// 左邊返回入棧
if begin < loc-1 {
lSize = loc - 1 - begin
}
// 兩個範圍,讓範圍小的先入棧,減少人工棧空間
if rSize != -1 && lSize != -1 {
if lSize > rSize {
helpStack.Push(end)
helpStack.Push(loc + 1)
helpStack.Push(loc - 1)
helpStack.Push(begin)
} else {
helpStack.Push(loc - 1)
helpStack.Push(begin)
helpStack.Push(end)
helpStack.Push(loc + 1)
}
} else {
if rSize != -1 {
helpStack.Push(end)
helpStack.Push(loc + 1)
}
if lSize != -1 {
helpStack.Push(loc - 1)
helpStack.Push(begin)
}
}
}
}
完整的程式如下:
package main
import (
"fmt"
"sync"
)
// 連結串列棧,後進先出
type LinkStack struct {
root *LinkNode // 連結串列起點
size int // 棧的元素數量
lock sync.Mutex // 為了併發安全使用的鎖
}
// 連結串列節點
type LinkNode struct {
Next *LinkNode
Value int
}
// 入棧
func (stack *LinkStack) Push(v int) {
stack.lock.Lock()
defer stack.lock.Unlock()
// 如果棧頂為空,那麼增加節點
if stack.root == nil {
stack.root = new(LinkNode)
stack.root.Value = v
} else {
// 否則新元素插入連結串列的頭部
// 原來的連結串列
preNode := stack.root
// 新節點
newNode := new(LinkNode)
newNode.Value = v
// 原來的連結串列連結到新元素後面
newNode.Next = preNode
// 將新節點放在頭部
stack.root = newNode
}
// 棧中元素數量+1
stack.size = stack.size + 1
}
// 出棧
func (stack *LinkStack) Pop() int {
stack.lock.Lock()
defer stack.lock.Unlock()
// 棧中元素已空
if stack.size == 0 {
panic("empty")
}
// 頂部元素要出棧
topNode := stack.root
v := topNode.Value
// 將頂部元素的後繼連結鏈上
stack.root = topNode.Next
// 棧中元素數量-1
stack.size = stack.size - 1
return v
}
// 棧是否為空
func (stack *LinkStack) IsEmpty() bool {
return stack.size == 0
}
// 非遞迴快速排序
func QuickSort5(array []int) {
// 人工棧
helpStack := new(LinkStack)
// 第一次初始化棧,推入下標0,len(array)-1,表示第一次對全陣列範圍切分
helpStack.Push(len(array) - 1)
helpStack.Push(0)
// 棧非空證明存在未排序的部分
for !helpStack.IsEmpty() {
// 出棧,對begin-end範圍進行切分排序
begin := helpStack.Pop() // 範圍區間左邊
end := helpStack.Pop() // 範圍
// 進行切分
loc := partition(array, begin, end)
// 右邊範圍入棧
if loc+1 < end {
helpStack.Push(end)
helpStack.Push(loc + 1)
}
// 左邊返回入棧
if begin < loc-1 {
helpStack.Push(loc - 1)
helpStack.Push(begin)
}
}
}
// 非遞迴快速排序優化
func QuickSort6(array []int) {
// 人工棧
helpStack := new(LinkStack)
// 第一次初始化棧,推入下標0,len(array)-1,表示第一次對全陣列範圍切分
helpStack.Push(len(array) - 1)
helpStack.Push(0)
// 棧非空證明存在未排序的部分
for !helpStack.IsEmpty() {
// 出棧,對begin-end範圍進行切分排序
begin := helpStack.Pop() // 範圍區間左邊
end := helpStack.Pop() // 範圍
// 進行切分
loc := partition(array, begin, end)
// 切分後右邊範圍大小
rSize := -1
// 切分後左邊範圍大小
lSize := -1
// 右邊範圍入棧
if loc+1 < end {
rSize = end - (loc + 1)
}
// 左邊返回入棧
if begin < loc-1 {
lSize = loc - 1 - begin
}
// 兩個範圍,讓範圍小的先入棧,減少人工棧空間
if rSize != -1 && lSize != -1 {
if lSize > rSize {
helpStack.Push(end)
helpStack.Push(loc + 1)
helpStack.Push(loc - 1)
helpStack.Push(begin)
} else {
helpStack.Push(loc - 1)
helpStack.Push(begin)
helpStack.Push(end)
helpStack.Push(loc + 1)
}
} else {
if rSize != -1 {
helpStack.Push(end)
helpStack.Push(loc + 1)
}
if lSize != -1 {
helpStack.Push(loc - 1)
helpStack.Push(begin)
}
}
}
}
// 切分函式,並返回切分元素的下標
func partition(array []int, begin, end int) int {
i := begin + 1 // 將array[begin]作為基準數,因此從array[begin+1]開始與基準數比較!
j := end // array[end]是陣列的最後一位
// 沒重合之前
for i < j {
if array[i] > array[begin] {
array[i], array[j] = array[j], array[i] // 交換
j--
} else {
i++
}
}
/* 跳出while迴圈後,i = j。
* 此時陣列被分割成兩個部分 --> array[begin+1] ~ array[i-1] < array[begin]
* --> array[i+1] ~ array[end] > array[begin]
* 這個時候將陣列array分成兩個部分,再將array[i]與array[begin]進行比較,決定array[i]的位置。
* 最後將array[i]與array[begin]交換,進行兩個分割部分的排序!以此類推,直到最後i = j不滿足條件就退出!
*/
if array[i] >= array[begin] { // 這裡必須要取等“>=”,否則陣列元素由相同的值組成時,會出現錯誤!
i--
}
array[begin], array[i] = array[i], array[begin]
return i
}
func main() {
list3 := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
QuickSort5(list3)
fmt.Println(list3)
list4 := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
QuickSort6(list4)
fmt.Println(list4)
}
輸出:
[1 3 4 5 6 6 6 8 9 14 25 49]
[1 3 4 5 6 6 6 8 9 14 25 49]
使用人工棧替代遞迴的程式棧,換湯不換藥,速度並沒有什麼變化,但是程式碼可讀性降低。
五、補充:內建庫使用快速排序的原因
首先堆排序,歸併排序最好最壞時間複雜度都是:O(nlogn)
,而快速排序最壞的時間複雜度是:O(n^2)
,但是很多程式語言內建的排序演算法使用的仍然是快速排序,這是為什麼?
- 這個問題有偏頗,選擇排序演算法要看具體的場景,
Linux
核心用的排序演算法就是堆排序,而Java
對於數量比較多的複雜物件排序,內建排序使用的是歸併排序,只是一般情況下,快速排序更快。 - 歸併排序有兩個穩定,第一個穩定是排序前後相同的元素位置不變,第二個穩定是,每次都是很平均地進行排序,讀取資料也是順序讀取,能夠利用儲存器快取的特徵,比如從磁碟讀取資料進行排序。因為排序過程需要佔用額外的輔助陣列空間,所以這部分有代價損耗,但是原地手搖的歸併排序克服了這個缺陷。
- 複雜度中,大
O
有一個常數項被省略了,堆排序每次取最大的值之後,都需要進行節點翻轉,重新恢復堆的特徵,做了大量無用功,常數項比快速排序大,大部分情況下比快速排序慢很多。但是堆排序時間較穩定,不會出現快排最壞O(n^2)
的情況,且省空間,不需要額外的儲存空間和棧空間。 - 當待排序數量大於16000個元素時,使用自底向上的堆排序比快速排序還快,可見此:https://core.ac.uk/download/pdf/82350265.pdf。
- 快速排序最壞情況下複雜度高,主要在於切分不像歸併排序一樣平均,而是很依賴基準數的現在,我們通過改進,比如隨機數,三切分等,這種最壞情況的概率極大的降低。大多數情況下,它並不會那麼地壞,大多數快才是真的塊。
- 歸併排序和快速排序都是分治法,排序的資料都是相鄰的,而堆排序比較的數可能跨越很大的範圍,導致區域性性命中率降低,不能利用現代儲存器快取的特徵,載入資料過程會損失效能。
對穩定性有要求的,要求排序前後相同元素位置不變,可以使用歸併排序,Java
中的複雜物件型別,要求排序前後位置不能發生變化,所以小規模資料下使用了直接插入排序,大規模資料下使用了歸併排序。
對棧,儲存空間有要求的可以使用堆排序,比如Linux
核心棧小,快速排序佔用程式棧太大了,使用快速排序可能棧溢位,所以使用了堆排序。
在Golang
中,標準庫sort
中對切片進行穩定排序:
func SliceStable(slice interface{}, less func(i, j int) bool) {
rv := reflectValueOf(slice)
swap := reflectSwapper(slice)
stable_func(lessSwap{less, swap}, rv.Len())
}
func stable_func(data lessSwap, n int) {
blockSize := 20
a, b := 0, blockSize
for b <= n {
insertionSort_func(data, a, b)
a = b
b += blockSize
}
insertionSort_func(data, a, n)
for blockSize < n {
a, b = 0, 2*blockSize
for b <= n {
symMerge_func(data, a, a+blockSize, b)
a = b
b += 2 * blockSize
}
if m := a + blockSize; m < n {
symMerge_func(data, a, m, n)
}
blockSize *= 2
}
}
會先按照20
個元素的範圍,對整個切片分段進行插入排序,因為小陣列插入排序效率高,然後再對這些已排好序的小陣列進行歸併排序。其中歸併排序還使用了原地排序,節約了輔助空間。
而一般的排序:
func Slice(slice interface{}, less func(i, j int) bool) {
rv := reflectValueOf(slice)
swap := reflectSwapper(slice)
length := rv.Len()
quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
}
func quickSort_func(data lessSwap, a, b, maxDepth int) {
for b-a > 12 {
if maxDepth == 0 {
heapSort_func(data, a, b)
return
}
maxDepth--
mlo, mhi := doPivot_func(data, a, b)
if mlo-a < b-mhi {
quickSort_func(data, a, mlo, maxDepth)
a = mhi
} else {
quickSort_func(data, mhi, b, maxDepth)
b = mlo
}
}
if b-a > 1 {
for i := a + 6; i < b; i++ {
if data.Less(i, i-6) {
data.Swap(i, i-6)
}
}
insertionSort_func(data, a, b)
}
}
func doPivot_func(data lessSwap, lo, hi int) (midlo, midhi int) {
m := int(uint(lo+hi) >> 1)
if hi-lo > 40 {
s := (hi - lo) / 8
medianOfThree_func(data, lo, lo+s, lo+2*s)
medianOfThree_func(data, m, m-s, m+s)
medianOfThree_func(data, hi-1, hi-1-s, hi-1-2*s)
}
medianOfThree_func(data, lo, m, hi-1)
pivot := lo
a, c := lo+1, hi-1
for ; a < c && data.Less(a, pivot); a++ {
}
b := a
for {
for ; b < c && !data.Less(pivot, b); b++ {
}
for ; b < c && data.Less(pivot, c-1); c-- {
}
if b >= c {
break
}
data.Swap(b, c-1)
b++
c--
}
protect := hi-c < 5
if !protect && hi-c < (hi-lo)/4 {
dups := 0
if !data.Less(pivot, hi-1) {
data.Swap(c, hi-1)
c++
dups++
}
if !data.Less(b-1, pivot) {
b--
dups++
}
if !data.Less(m, pivot) {
data.Swap(m, b-1)
b--
dups++
}
protect = dups > 1
}
if protect {
for {
for ; a < b && !data.Less(b-1, pivot); b-- {
}
for ; a < b && data.Less(a, pivot); a++ {
}
if a >= b {
break
}
data.Swap(a, b-1)
a++
b--
}
}
data.Swap(pivot, b-1)
return b - 1, c
}
快速排序限制程式棧的層數為:2*ceil(log(n+1))
,當遞迴超過該層時表示程式棧過深,那麼轉為堆排序。
上述快速排序還使用了三種優化,第一種是遞迴時小陣列轉為插入排序,第二種是使用了中位數基準數,第三種使用了三切分。
系列文章入口
我是陳星星,歡迎閱讀我親自寫的 資料結構和演算法(Golang實現),文章首發於 閱讀更友好的GitBook。
- 資料結構和演算法(Golang實現)(1)簡單入門Golang-前言
- 資料結構和演算法(Golang實現)(2)簡單入門Golang-包、變數和函式
- 資料結構和演算法(Golang實現)(3)簡單入門Golang-流程控制語句
- 資料結構和演算法(Golang實現)(4)簡單入門Golang-結構體和方法
- 資料結構和演算法(Golang實現)(5)簡單入門Golang-介面
- 資料結構和演算法(Golang實現)(6)簡單入門Golang-併發、協程和通道
- 資料結構和演算法(Golang實現)(7)簡單入門Golang-標準庫
- 資料結構和演算法(Golang實現)(8.1)基礎知識-前言
- 資料結構和演算法(Golang實現)(8.2)基礎知識-分治法和遞迴
- 資料結構和演算法(Golang實現)(9)基礎知識-演算法複雜度及漸進符號
- 資料結構和演算法(Golang實現)(10)基礎知識-演算法複雜度主方法
- 資料結構和演算法(Golang實現)(11)常見資料結構-前言
- 資料結構和演算法(Golang實現)(12)常見資料結構-連結串列
- 資料結構和演算法(Golang實現)(13)常見資料結構-可變長陣列
- 資料結構和演算法(Golang實現)(14)常見資料結構-棧和佇列
- 資料結構和演算法(Golang實現)(15)常見資料結構-列表
- 資料結構和演算法(Golang實現)(16)常見資料結構-字典
- 資料結構和演算法(Golang實現)(17)常見資料結構-樹
- 資料結構和演算法(Golang實現)(18)排序演算法-前言
- 資料結構和演算法(Golang實現)(19)排序演算法-氣泡排序
- 資料結構和演算法(Golang實現)(20)排序演算法-選擇排序
- 資料結構和演算法(Golang實現)(21)排序演算法-插入排序
- 資料結構和演算法(Golang實現)(22)排序演算法-希爾排序
- 資料結構和演算法(Golang實現)(23)排序演算法-歸併排序
- 資料結構和演算法(Golang實現)(24)排序演算法-優先佇列及堆排序
- 資料結構和演算法(Golang實現)(25)排序演算法-快速排序
- 資料結構和演算法(Golang實現)(26)查詢演算法-雜湊表
- 資料結構和演算法(Golang實現)(27)查詢演算法-二叉查詢樹
- 資料結構和演算法(Golang實現)(28)查詢演算法-AVL樹
- 資料結構和演算法(Golang實現)(29)查詢演算法-2-3樹和左傾紅黑樹
- 資料結構和演算法(Golang實現)(30)查詢演算法-2-3-4樹和普通紅黑樹