數據結構和算法(Golang實現)(25)排序算法-快速排序

時間 2021-05-30

標籤 c++ 算法編程 segmentfault 數組緩存安全數據結構併發 app 欄目 Go 简体版

原文原文鏈接

快速排序

快速排序是一種分治策略的排序算法，是由英國計算機科學家Tony Hoare發明的，該算法被髮布在1961年的Communications of the ACM 國際計算機學會月刊。c++

注：ACM = Association for Computing Machinery，國際計算機學會，世界性的計算機從業員專業組織，創立於1947年，是世界上第一個科學性及教育性計算機學會。算法

快速排序是對冒泡排序的一種改進，也屬於交換類的排序算法。編程

1、算法介紹

快速排序經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據都比另一部分的全部數據都要小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程能夠遞歸進行，以此達到整個數據變成有序序列。segmentfault

步驟以下：數組

先從數列中取出一個數做爲基準數。通常取第一個數。
分區過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。
再對左右區間重複第二步，直到各區間只有一個數。

舉一個例子：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)。對比以前介紹的排序算法，快速排序比那些動不動就是平方級別的初級排序算法更佳。app

切分的結果極大地影響快速排序的性能，爲了不切分不均勻狀況的發生，有幾種方法改進：

每次進行快速排序切分時，先將數列隨機打亂，再進行切分，這樣隨機加了個震盪，減小不均勻的狀況。固然，也能夠隨機選擇一個基準數，而不是選第一個數。
每次取數列頭部，中部，尾部三個數，取三個數的中位數爲基準數進行切分。

方法 1 相對好，而方法 2 引入了額外的比較操做，通常狀況下咱們能夠隨機選擇一個基準數。

快速排序使用原地排序，存儲空間複雜度爲：O(1)。而由於遞歸棧的影響，遞歸的程序棧開闢的層數範圍在logn~n，因此遞歸棧的空間複雜度爲：O(logn)~log(n)，最壞爲：log(n)，當元素較多時，程序棧可能溢出。經過改進算法，使用僞尾遞歸進行優化，遞歸棧的空間複雜度能夠減少到O(logn)，能夠見下面算法優化。

快速排序是不穩定的，由於切分過程當中進行了交換，相同值的元素可能發生位置變化。

2、算法實現

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]

示例圖：

快速排序，每一次切分都維護兩個下標，進行推動，最後將數列分紅兩部分。

3、算法改進

快速排序能夠繼續進行算法改進。

在小規模數組的狀況下，直接插入排序的效率最好，當快速排序遞歸部分進入小數組範圍，能夠切換成直接插入排序。
排序數列可能存在大量重複值，使用三向切分快速排序，將數組分紅三部分，大於基準數，等於基準數，小於基準數，這個時候須要維護三個下標。
使用僞尾遞歸減小程序棧空間佔用，使得棧空間複雜度從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)常數層好不少。

4、補充：非遞歸寫法

非遞歸寫法僅僅是將以前的遞歸棧轉化爲本身維持的手工棧。

// 非遞歸快速排序
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]

使用人工棧替代遞歸的程序棧，換湯不換藥，速度並無什麼變化，可是代碼可讀性下降。

5、補充：內置庫使用快速排序的緣由

首先堆排序，歸併排序最好最壞時間複雜度都是：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))，當遞歸超過該層時表示程序棧過深，那麼轉爲堆排序。

上述快速排序還使用了三種優化，第一種是遞歸時小數組轉爲插入排序，第二種是使用了中位數基準數，第三種使用了三切分。