快速排序

快速排序是一種分治策略的排序演算法，是由英國電腦科學家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實現)(25)排序演算法-快速排序