歸併排序 - Algorithms, Part I, week 3 MERGESORTS

前言

本週講解兩個50多年前發明，但今天仍然很重要的經典算法 (歸併排序和快速排序) 之一 -- 歸併排序，幾乎每一個軟件系統中均可以找到其中一個或兩個的實現，並研究這些經典方法的新變革。咱們的涉及範圍從數學模型中解釋爲何這些方法有效到使這些算法適應現代系統的實際應用的細節。

Mergesort。咱們研究 mergesort 算法，並證實它保證對 n 項的任何數組進行排序，最多隻能進行 nlgn 次的比較。咱們還考慮一個非遞歸的自下而上版本。咱們證實，在最壞的狀況下，任何基於比較的排序算法必須至少進行 ~nlgn 的比較。咱們討論對咱們正在排序的對象使用不一樣的排序以及相關的穩定性概念。

上一篇：基本數據類型
下一篇：快速排序

這章咱們討論歸併排序，這是計算基礎中的兩個重要排序算法之一
咱們已經對一些算法有了科學全面的認知，這些算法被大量運用在系統排序和應用內排序超過50多年，咱們以後所要看到的快速排序更是被在科學和工程中被譽爲20世紀10大算法之一

歸併排序

概貌

因此歸併排序究竟是什麼樣的?

基本計劃流程：

• 將陣列分紅兩半
• 遞歸排序每一半
• 合併兩半

它的思想其實很簡單, 只要把數組一分爲二, 而後再不斷將小數組遞歸地一分爲二下去, 通過一些排序再將它們合併起來, 這就是歸併排序的大體思想, 這是人們在計算機上實現的最先的算法之一.
(EDVAC 計算機是最先的通用型計算機之一, 馮諾依曼認爲在他的 EDVAC 中須要一種排序算法, 因而他提出了歸併排序, 所以他被公認爲是歸併排序之父)

歸併排序的核心就是「並」。因此要理解如何歸併，先考慮一種抽象的「原位歸併」。

原位歸併

也叫 Top-down mergesort. 下邊還有歸併的另外一種實現，叫 Bottom-up mergesort.

目標 給定一個數組，它的前一半(a[lo]-[mid]) 和 後一半([mid + 1]-[hi]) 已經是排好序的，咱們所要作的就是將這兩個子數組合併成一個大的排好序的數組

看一個抽象原位歸併演示

1.在排序以前咱們須要一個輔助數組，用於記錄數據，這是實現歸併的最簡單的方式

2.首先將原數組中全部東西拷貝進輔助數組，以後咱們就要以排好的順序將它們拷貝回原數組
這時咱們須要三個下標：i 用於指向左邊子數組；j 指向右邊子數組；k指向原數組即排好序的數組。

3.首先取 i 和 j 所指數字中取其中小的放入原數組k的位置，當一個被拿走以後，拿走位置的指針 (此次是 j) 和 k 遞增

4.一樣取 i 和 j 中小的那個移向 k 的位置，再同時增長移動位置的指針(此次仍是 j 和 k)

以此類推。完整演示地址：在此
這就是一種歸併方式： 用了一個輔助數組，將它們移出來又排好序放回去。
這就是歸併部分的代碼，徹底依着以前的演示

Java 實現

public class Merge {

    private static void merge(Comparable[] a, Comparable[] aux, int lo, int mid, int hi) {
/**
 * assertion功能: 方便咱們找出漏洞而且肯定算法的正確
 * 想肯定a[lo] 到 a[mid] 和 a[mid+1] 到 a[hi] 是否已經是排好序的
 */
        assert isSorted(a, lo, mid);
        assert isSorted(a, mid + 1, hi);

        //拷貝全部東西進輔助數組
        for (int k = lo; k <= hi; k++)
            aux[k] = a[k];
        /**
         * 完成歸併
         * 初始化 i 在左半邊的最左端
         * j 在右半邊最左端
         * 指針 k 從 lo 開始
         * 比較輔助數組中 i 和 j 誰更小，並將小的那個的值移向 k
         **/
        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++) {
            //若是 i 走到邊界了，就只將 j 的值都移上去
            if (i > mid) a[k] = aux[j++];
            //若是 j 走到邊界了，就只將 i 的值都移上去
            else if (j > hi) a[k] = aux[i++];
            else if (less(aux[j], aux[i])) a[k] = aux[j++];
            else a[k] = aux[i++];
        }
        //最後再檢查最終合併後的時候排好序
        assert isSorted(a, lo, hi);
    }

    // 遞歸的 sort 方法
    private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi) {
        if (hi <= lo) return;
        int mid = lo + (hi - lo) / 2;
        sort(a, aux, lo, mid);
        sort(a, aux, mid + 1, hi);
        merge(a, aux, lo, mid, hi);
    }

    // 對外提供接口中 sort 函數
    public static void sort(Comparable[] a) {
        //建立輔助數組
        Comparable[] aux = new Comparable[a.length];
        sort(a, aux, 0, a.length - 1);
    }
}

完整「原位」歸併代碼：在此

在這個簡單的實現中傳入了 Comparable 類型的原數組 a[] 和 輔助數組 aux[], 還有三個參數 lo, mid, and hi.
lo指向的是兩個將要合併的子數組的頭部 mid指向前一個子數組的末端 因此咱們的前提是lo到mid時排好的 從mid+1到hi也是排好的

有了歸併，排序中遞歸的就簡單多了。
sort() 在遞歸調用前先檢查下標，而後像二分查找那樣計算中點值。sort前半部分，再sort後半部分，而後merge
對外提供接口中 sort 函數只接收一個參數，建立輔助數組的任務就交給這個 sort()

這裏關鍵在於不要將輔助數組在遞歸的 sort() 中建立, 由於那會多出許多額外的小數組的花費, 若是一個歸併排序效率很低一般都是由這引發 這是一個很直接的實現方式。也是依據了咱們看到屢次的一個思想--分治法：即解決問題時將其一分爲二，分別解決兩個小問題，再將它們合併起來

Assertion

通常來講Java程序員，認爲加入這些 assert 是有益的：

• 幫助咱們發現漏洞
• 同時也提示了之間的代碼的功能

這個歸併代碼就是很好的例子，如此以代碼的形式加入 assert 語句代表了接下來你想作什麼，在代碼最後加上 assert 語句代表了你作了什麼。
你不只肯定了代碼的正確，也告訴閱讀代碼的人你所幹的事情。

Java 中 asset 語句接受一個 boolean 值。isSorted 函數前面已經寫過了(請回復 -- 基本排序)，若是排好序返回 true，反之返回 false. assert 在驗證到沒正確排序時會拋出異常.

assert 能夠在運行時禁用.
這頗有用由於你能夠把 asset 語句一直放在代碼中, 編程時供本身所需, 禁用後在最終上線程序中不會有額外代碼。所以 assertion 默認是禁用的。出錯的時候人們還能夠啓用assertion而後找到錯誤所在。

java -ea MyProgram //啓用 assertions
java -da MyProgram //禁用 assertions(默認)

因此平時最好像以前的例子那樣加入assert語句，而且不讓他們出如今產品代碼中，並且不要用額外的參數來作檢查。

軌跡圖

這幅圖顯示了每次調用 merge 時的操做。
咱們將一個大的問題對半分，再將其中的一半對半分，對於那些分到不能再分單個元素，咱們作的就是兩兩間的比較。
兩個單元素數組的合併實際就是對這兩個數進行了排序，即 M-E 變爲 E-M，一樣再對後一組的兩個數歸併排序，即 R-G 變爲 G-R，再將兩單元數組歸併成四單元數組,即 E-M 和 G-R 歸併爲 E-G-M-R。
一樣再對後兩對歸併(E-S,O-R)，這樣就獲得兩個四單元數組(E-G-M-R 和 E-O-R-S), 再歸併獲得八單元組(E-E-G-M-O-R-R-S).
右邊的一半也是同理,最終兩個八單元合併,獲得最終的結果.
觀察這個軌跡圖對於學習遞歸算法是頗有幫助的.

Q. 如下哪一種子數組長度會在對長度爲 12 的數組進行歸併排序時出現？
A. { 1, 2, 3, 4, 6, 8, 12 }
B. { 1, 2, 3, 6, 12 }
C. { 1, 2, 4, 8, 12 }
D. { 1, 3, 6, 9, 12 }

算法分析

實證分析

運行時間估計：

能夠將歸併排序用在大量數據中，這是個很是高效的算法。如表中所示，若是要對大量數據進行插入排序，假設有十億個元素，用家裏的電腦要花幾個世紀。就算目前的超級計算機也要花費一個星期或更多。
可是擁有一個高效的算法，你對十億個元素排序，家用電腦也只需半小時，超級計算機更是一瞬間便可完成，一些小型的問題PC也可迅速完成。所以要麼你有不少錢和時間，要麼你要有一個好的算法。這是咱們在這門課中的核心主題，即一個好的算法遠比差的算法所花時間和金錢高效得多。

效率分析

這些數學的東西才能展現出分治法的強大 展現出歸併算法如何在 nlogn 時間中解決了選擇排序和插入排序須要 N^2 時間才能解決的問題。

比較次數

命題：對於大小爲 n 的數組，歸併排序須要最多 nlogn 次比較 和 6nlogn 次數組訪問

證實：證實這個結論就是須要從以前的代碼中得出遞推關係式, 這即是代碼所反映的數學問題。
若是對 n 個元素排序，用關於 n 的函數 C(n) 來表示須要比較的次數

歸併時左半部分和右半部分元素個數就用 n/2 上取整 和 n/2 下取整來表示, 這就是兩個子數組的大小. 由於咱們遞歸地調用函數, 因此括號裏就是每次遞歸時分割後子數組的大小, 因而整個一項就是子數組中這些數排序須要的比較次數.
對於左半部分比較次數, 就是關於 n/2 上取整的函數 C(n/2); 對於右邊同理. 二合併時咱們須要至多 n-1 次比較
由於若是左右沒有一邊提早排完,就須要 n-1 次比較. 這也只是 n 大於等於 1 的狀況. 若是隻有一個單元, 是不須要任何比較的, C(1) = 0.
因而這個從代碼中考查得來的公式就能精確計算所須要的比較次數上界.

關於這些求這些複雜公式的通項，具體能夠回顧離散數學

咱們能夠看一下當 n 爲 2 的冪時的狀況(但結論是對 n 爲任意數都成立的, 咱們能夠經過數學概括法來證實)

D(n) = 2 D(n / 2) + n, for n > 1, with D(1) = 0.

和前面類似的遞推關係式, 咱們將展現一種證實方法.

分治遞歸
都假設 n 爲 2 的冪次，那 n^2 除以二也是 2 的冪, 這是顯然的。
命題： 當 n 是 2 的冪次時的狀況, 即，若是 D(n) 知足 D(n) = 2 D(n / 2) + n，當 n > 1, 當且僅當 n=1 時 D(1)=0，通項 D(n) = nlogn.

圖示法

!

能夠看到每次歸併，對於一整層的比較次數都是 N 次，因此共有多少層? 將 N 不斷除 2 一直到等於2，一共有 logN 層(以2爲底), 因此總共有 NlogN 次比較。歸併的所有開銷就在於比較次數, 也就是 NlogN. 這就是用圖示法來計算遞推式.

數組訪問

命題：對於大小爲 n 的數組，歸併排序使用 ≤ 6nlgn 個數組訪問來排序數組

對於數組訪問次數的計算類似, 只是在歸併的時候後面加上的是 6n

• 將 a 數組複製到 aux 數組：數組訪問 2 n 次; 若是 less() 方法運行了 2 n 次，若是每次 less() 都返回 true, 那麼又須要 2 * n 次來將輔助數組中的值儲存回原數組，因此總共 6n 次

A(n) ≤ A(⎡n / 2⎤) + A(⎣n / 2⎦) + 6n for n > 1, with A(1) = 0.

Key point. 任何具備如下結構的算法都須要 nlogn 時間

內存佔用

命題: Mergesort 使用與 n 成比例的額外空間
歸併排序的一大特色就是它須要隨 n 增大而增大的額外空間, 由於有那個額外的輔助數組.

證實： 對於最後一次合併，數組aux []的長度必須爲n。
咱們將兩個子數組看似原地排序, 但實際上並非真正的「原地」, 由於咱們用到了額外的數組。

若是使用 ≤ clogn 的額外內存，則排序算法就是原地排序，例如：
插入排序，選擇排序，和 希爾排序

這些排序算法不須要額外空間，但歸併排序你只能放一半，另外一半要留給輔助數組。

算法改進

若是你以爲如今所學的太簡單，而在思考一種真正的原地歸，其實人們已經有一些方法來完成，但只是理論上可行，實踐太過繁瑣，而沒有能被運用，也許存有簡單的方式實現原地歸併，這就有待咱們去發現。
不過如今有些切實可行的改進，能讓歸併算法變得高效，這就來看一下由於這種技巧也能用於其餘算法：

• 使用數組長度爲 ~ ½ n 的額外數組 aux[] 代替長度爲 n 的額外數組
  首先對特別小的數組運用歸併排序太過複雜，好比大小爲二三四的數組，歸併它們時調用函數也會有開銷，更糟糕的是不斷地遞歸會分出不少不少小數組，因此第一個改進就是進行切分，對小於某個數值的小數組採用插入排序，這樣能更加有效。 因此加入這一行能讓歸併更快，快大約20%。

private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi)
{
 //Cutoff to insertion sort for ≈ 7 items.
 if (hi <= lo + CUTOFF - 1)
 {
     Insertion.sort(a, lo, hi);
     return;
 }
     int mid = lo + (hi - lo) / 2;
     sort (a, aux, lo, mid);
     sort (a, aux, mid+1, hi);
     merge(a, aux, lo, mid, hi);
}

• 第二個對算法的改進能夠是當(merge以前)兩個子數組間若是已經是有序，即可跳過此輪歸併。判斷這種狀況只需判斷前一半最大的數是否小於後一半最小的數，僅此而已，So easy. 所以咱們就在歸併前加一句判斷，檢測子數組是否有序，這樣只要在每一個歸併前檢測一下，也只需線性複雜度的時間便可完成，這至少在一些狀況下是有幫助的

private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi)
{
     if (hi <= lo) return;
     int mid = lo + (hi - lo) / 2;
     sort (a, aux, lo, mid);
     sort (a, aux, mid+1, hi);
     //are subarrays sorted?
     if (!less(a[mid+1], a[mid])) return;
     merge(a, aux, lo, mid, hi);
}

另外一個能夠改進的比較費解, 因此只推薦於專業人士.改進在於節省下拷貝到輔助數組的時間(不是空間)。這種改進至關於每一輪遞歸時轉換一下原數組和輔助數組的角色，不過仍是需那個輔助數組。代碼以下：

將sort結果放入另外一數組，將merge結果合併回原數組，因此遞歸函數同時也完成了交換兩個數組角色的任務，這就意味着不用花時間拷貝元素進輔助數組，就節省下了一點時間。

完整代碼：在此

穩定性

咱們上訴實現的歸併排序是穩定的嗎？是穩定的。
穩定性又是指什麼。請查看前一章：基本排序

歸併排序是穩定的，只要 merge() 操做是穩定的，它就是穩定的。

public class Merge
{
 private static void merge(...)
 { /* as before */ }

 private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi)
 {
     if (hi <= lo) return;
     int mid = lo + (hi - lo) / 2;
     sort(a, aux, lo, mid);
     sort(a, aux, mid+1, hi);
     //這個操做是穩定的
     merge(a, aux, lo, mid, hi);
 }
 public static void sort(Comparable[] a)
 { /* as before */ }
}

這些操做是否穩定取決於咱們的代碼怎麼寫。在咱們的代碼中，

private static void merge(...)
{
 for (int k = lo; k <= hi; k++)
 aux[k] = a[k];
 int i = lo, j = mid+1;
 for (int k = lo; k <= hi; k++)
 {
     if (i > mid) a[k] = aux[j++];
     else if (j > hi) a[k] = aux[i++];
     else if (less(aux[j], aux[i])) a[k] = aux[j++];
     // 若是兩個鍵是相等(或左邊子數組的值小),將輔助數組左邊的值放到原數組中
     else a[k] = aux[i++];
 }
}

若是兩個鍵是相等的，它取來自左邊子數組的值，那麼這意味着若是有兩組相等的鍵，它將老是保留它們的相對順序，先左再右，這就足夠表示歸併操做是穩定的了，所以歸併排序是穩定的。穩定性是排序算法中一個重要的性質。歸併算法不只高效並且也是穩定的。

bottom-up 歸併排序

這是一種簡單，沒有遞歸的，歸併排序的實現方法

歸併規則

接下來，咱們將看從下往上方式的歸併排序。
歸併排序做爲遞歸程序是簡單易理解的。雖然這個從下往上的方式不是遞歸，但也比較容易理解。
其基本方法爲：

• 把開始未排序的每個元素視爲已排序的序列，該序列長度爲 1
• 接下來此方法將遍歷併合並 1 對長度爲 1 的子序列，成爲一組長度爲二的子序列
• 而後對長度爲 2 的子序列進行合併再排序，這樣咱們就有一組長度爲 4 的已排序的子序列
• 而後合併長度爲 8 以此類推

• 從這個例子中咱們能夠看出，從長度爲 1 的子序列開始，合併排序成長度爲 2 的子序列 E-M，而後不斷重複這一過程，直到咱們從 16 個長度爲 1 的子序列變爲兩組長度爲八的子序列
• 在第二輪中，咱們將 E-M 與另外一組 G-R 合併排序爲E-G-M-R，以及 E-S 與 O-R 合併爲 E-O-R-S，以此類推，咱們有四組長度爲四的子序列
• 第三輪咱們將每兩組合並，獲得兩組長度爲八的子序列，最後一輪的到一個徹底排序的序列。

這樣作的好處是這一操做遍歷整個序列而且不須要遞歸。

Java 實現

public class MergeBU
{
 private static void merge(...)
 { /* as before */ }

 public static void sort(Comparable[] a)
 {
     int n = a.length;
     Comparable[] aux = new Comparable[n];
     for (int sz = 1; sz < n; sz = sz+sz)
         for (int lo = 0; lo < n-sz; lo += sz+sz)
             merge(a, aux, lo, lo+sz-1, Math.min(lo+sz+sz-1, n-1));
     }
}

完整代碼：在此

從以上代碼能夠看出它很是容易編寫，

• 採用一樣的合併代碼並運用嵌套循環(兩個 for 循環)，sz 子序列的大小，第一層循環是 logn 時間複雜度，由於每次咱們合併序列爲兩倍長，即 sz = sz+sz，直到長度爲 n。
• 而後咱們從 low 到 low+size-1 排序

這就是一個徹底達到業界標準的排序代碼，相對普通歸併排序，它的惟一負面影響在於須要額外存儲空間，大小與序列長度有關。
除了這點外這是一個很好的歸併排序方法。
以上是從下往上的歸併排序。不管大小，從下往上的歸併排序 時間複雜度爲 logN。而每一輪須要進行N次比較，所以總複雜度爲 NlogN

排序複雜度

學習歸併排序能很好的來幫助理解排序問題自身存在的困難性，如今把這個困難度稱爲複雜度，接下來咱們將會看關於複雜度的問題。

計算複雜性

計算複雜性: 研究解決特定問題 X 的(全部)算法效率的框架.

而爲了使其易於理解，咱們須要創建所謂的計算模型，即
計算模型： 算法容許執行的操做

對於那種直截了當的排序，咱們要作的是創建一個成本模型來計算比較次數。
成本模型： 操做計數。

如今，在問題複雜度的框架內咱們只有兩樣東西：
上限： 算法所用開銷/成本的保證，它是由一些(!!)爲了解決問題而設計的算法提供。這個上限就表示解決這個問題有多難，咱們有個算法能夠解決它，而且這是最簡單的。
下限：下限，這是對全部算法的成本/開銷保證的限制。 沒有算法的下限比這個下線作得更好了。
而後咱們尋求所謂的最優的算法，就是解決問題「最優的」算法。
最優算法：待解問題的最佳成本保證的算法。也能夠說是算法的上限和下限是幾乎相同的(upper bound ~ lower bound),這是解決任何問題的最理想目標

所以，對於排序，讓咱們看看這各部分分別是什麼。
假設咱們訪問數據的惟一方式是經過比較操做，咱們全部能使用的只有比較操做，那麼一下就是用於分析排序複雜度的框架：

舉例：排序問題

計算複雜性(框架)

• 計算模型 model of computation：comparison tree (舊版本的講義decision tree)

  • comparison tree 意味着只能在進行比較的時候訪問數組(e.g., Java Comparable framework)

• 成本模型 cost model：比較的次數

  • 用 #compares 表示

• 上界upper bound：~ n lg n from mergesort.

  • 歸併排序提供了一個上界，它是一個保證排序完成的時間與 nlogn 成正比的算法.
• 下界lower bound：?
• 最優算法optimal algorithm：?

如下是證實排序下界的基本思想

比較樹

比方說，咱們有3個不一樣的項，a, b 和 c。不論使用什麼算法咱們首先要作的是比較三項中的兩項。

分解
好比說，這裏是a 和 b。比較以後，有兩種狀況 b < c / a < c, 也就是說，它們是有區別的, 在比較中間會有一些代碼，但無論怎樣接下來裏有不一樣的比較。

在這種狀況下，若是你從樹的頂部到尾部使用至多三次比較你就能夠肯定三個不一樣元素的順序。
用下限的觀點歸納就是你須要找到一個最小的比較次數來肯定N個元素的順序。

如今，樹的高度，樹的高度，正如我剛剛提到的，是最差狀況下比較的次數。
在全部排序中即便是考慮最差狀況下的樹，不管輸入是什麼，這棵樹告訴咱們一個邊界，以及算法的比較次數。

在每個可能的順序中都至少有一個順序，若是有一個順序沒有出如今針對特定算法的樹中，那麼這個算法就不能排序，不能告訴你兩種不一樣順序中間的差異。

做爲命題的下界，使用比較樹來證實任何基於排序算法的比較在最差狀況下不得不使用至少 log2(N) 因子的比較次數

而且，經過斯特林近似公式，咱們知道 lg(N!) 與 Nlg(N) 成正比。

基於比較的排序算法下界

命題：任何基於比較的排序算法,在最壞的狀況下, 必須至少作出 lg（n!）~nlgn 次比較。
證實：

• 假設數組由 n 個不一樣的值 a1 到 an 組成
• 由比較樹的高度h決定最壞狀況下排序須要比較的次數
• 高度爲 h 的二叉樹具備 ≤2^h 的葉子
• N! 個不一樣的順序 ⇒ n! 個可到達的葉子

h 是最會狀況下，也就是擁有最多葉子的狀況下的高度

• 2^h大於等於葉子節點的數量
• 葉子節點的數量大於等於N！

這推導出：樹的高度大於等於log2(N!)，根據斯特林公式，那是正比於 NlogN

這就是排序算法複雜度的下限。那麼上限的話，根據上邊排序問題的計算複雜性(框架)，已經知道上限是 NlogN, 那意味着歸併排序就是一個最優算法（上限 = 下線）

算法設計的首要目標：嘗試給咱們要解決的問題找到最優算法

經過複雜性分析得出的上下文結果：

咱們真正證實的是：
歸併排序，就比較的次數而言，是最優的
可是它就空間使用並不是最優，歸併排序使用多一倍的額外空間，正比於它要處理的數組的大小。而簡單的算法，好比插入或其餘排序，他們根本不適用任何額外的空間。

因此，當咱們關注實現並嘗試解決實際問題時，咱們把這些理論結果用做一個指導。
在這個例子裏，它告訴咱們的是：
好比，不要嘗試設計一個排序算法保證大致上比歸併排序，在比較次數上，更好的算法，比方說，1/2NlogN。有方法使用 1/2NlogN次比較的嗎？下限說，沒有；
再好比，也許有一個算法，使用 NlogN 次比較，同時也有最優的空間利用率。不只在時間上，也在空間上都是最優的。咱們即將看到在下面談論這樣的算法。

另外一件事是，特定模型下的下限是針對正在研究的特定計算模型得出的，在這個例子中是比較的次數。若是算法有關於鍵值的更多信息，它可能不成立。若是算法能夠利用如下優點，則下限可能不成立：

• 輸入數組的初始順序

  • 例如：插入排序只須要對部分排序的數組進行線性數量的比較。又或者若是輸入是幾乎排序好的。咱們曾看到對於幾乎排序好的文件，插入排序能夠是線性時間的。

• 鍵值的分佈

  • 若是有許多相等的鍵，咱們能夠令它排序得比 NlogN 更快。還有 3-way quicksort 快速排序僅須要在具備恆定數量的不一樣鍵的數組上進行線性數量的比較。(後續章節)

• 鍵的表示

  • 例如：基數排序不須要鍵值的比較 - 它們直接經過訪問數據. 經過字符/數位(digit)比較。後續章節）
    咱們能夠利用數字字符的比較，而不是整個鍵的比較，並對特定的實際應用獲得一個更快地排序。

計算複雜度是一個很是有用的方法來幫助咱們理解算法的性質並幫助指導咱們的設計決策。

附錄

Q. 如下哪一種子數組長度會在對長度爲 12 的數組進行歸併排序時出現？
B. { 1, 2, 3, 6, 12 }

對上下界理解的補充
到目前爲止，咱們一直關注這個問題：「給定一些問題X，咱們可否構建一個在大小爲n的輸入上運行時間O(f(n))的算法？」
這一般被稱爲上限問題，由於咱們正在肯定問題X的固有難度的上界，咱們的目標是使f(n)儘量小。

下界問題, 這裏，目標是證實任何算法必須花費時間 Ω(g(n))時間來解決問題，如今咱們的目標讓 g(n)儘量大。
下限幫助咱們理解咱們與某個問題的最佳解決方案有多接近：
例如，若是咱們有一個在上界時間 O(n log^2 n) 和 下界Ω(n log n) 運行的算法，那麼咱們的算法有log(n) 的 「差距」：咱們但願經過改進算法縮小這個差距。

一般，咱們將在限制的計算模型中證實下限，指定能夠對輸入執行什麼類型的操做以及執行什麼開銷。所以，這種模型的下限意味着若是咱們想要算法作得更好，咱們須要以某種方式在模型以外作一些事情。
今天咱們考慮基於比較的排序算法類。這些排序算法僅經過比較一對鍵值對輸入數組進行操做，在比較的基礎上移動元素。

面試問題

編程練習