查找和排序都是程序設(shè)計中經(jīng)常用到的算法。查找相對而言較為簡單，不外乎順序查找、二分查找、哈希表查找和二叉排序樹查找。排序常見的有插入排序、冒泡排序、歸并排序和快速排序。其中我們應(yīng)該重點(diǎn)掌握二分查找、歸并排序和快速排序，保證能隨時正確、完整地寫出它們的代碼。同時對其他的查找和排序必須能準(zhǔn)確說出它們的特點(diǎn)、對其平均時間復(fù)雜度、最差時間復(fù)雜度、額外空間消耗和穩(wěn)定性爛熟于胸。

1. 內(nèi)排序：

2. 插入排序：直接插入排序(InsertSort)、希爾排序（ShellSort）

3. 交換排序：冒泡排序(BubbleSort)、快速排序(QuickSort)

4. 選擇排序：直接選擇排序(SelectSort)、堆排序(HeapSort)

5. 歸并排序(MergeSort)

6. 基數(shù)排序(RadixSort)

7. 外排序：

8. 磁盤排序

9. 磁帶排序

10. 查找：

11. 線性表的查找：順序查找、折半查找（二分查找）、索引存儲結(jié)構(gòu)和分塊查找

12. 樹表的查找：二叉排序樹、平衡二叉樹、B-樹、B+樹

13. 哈希表查找

快速排序(QuickSort)

• 平均/最好時間復(fù)雜度：O(nlogn)
• 最差時間復(fù)雜度：O(n^2)
• 平均空間復(fù)雜度：O(logn)
• 最差空間復(fù)雜度：O(n)
• 穩(wěn)定性：不穩(wěn)定
• 時間復(fù)雜度分析：
  快速排序總體的平均效果是最好的，當(dāng)如果數(shù)組本身已經(jīng)排好序或幾乎有序的情況下，每輪排序又都是以最后一個數(shù)字作為比較的標(biāo)準(zhǔn)，那么排序的效率就只有O(n^2)。
• 空間復(fù)雜度分析：
  快速排序通過遞歸來實(shí)現(xiàn)，遞歸造成的棧空間的使用，最好情況，遞歸樹的深度為log2n，其空間復(fù)雜度為O(logn)，最壞情況，需要進(jìn)行n‐1遞歸調(diào)用，其空間復(fù)雜度為O(n)，平均情況，空間復(fù)雜度也為O(logn)。
• 穩(wěn)定性分析：
  由于關(guān)鍵字的比較和交換是跳躍進(jìn)行的，因此，快速排序是一種不穩(wěn)定的排序方法。
• 排序思想：
  快速排序是對冒泡排序的一種改進(jìn)。通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨(dú)立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分?jǐn)?shù)據(jù)分別進(jìn)行快速排序，整個排序過程可以遞歸進(jìn)行，以此達(dá)到整個數(shù)據(jù)變成有序序列。
• 經(jīng)典實(shí)現(xiàn)：

    void quickSort(int[] data, int length, int start, int end) {
        if (start == end)
            return ;

        int index = partition(data, length, start, end);
        if (index > start)
            quickSort(data, length, start, index-1);
        if(index < end)
            quickSort(data, length, index+1, end);
    }

    int partition(int[] data, int length, int start, int end) {
        if (data == null || length <= 0 || start < 0 || start >= length)
            throw new RuntimeException("Invalid Parameters");
        
        int index = randomInRange(start, end);
        swap(data, index, end);
        
        int small = start - 1;
        for (index = start; index < end; index++)
            if (data[index] < data[end]) {
                ++ small;
                if (small != index)
                    swap(data, small, index);
            }
        
        ++ small;
        swap(data, small, end);
        
        return small;
    }

    int randomInRange(int start, int end) {
        return new Random().nextInt(end-start+1)+start;
    }

    void swap(int[] data, int a, int b) {
        int tmp = data[a];
        data[a] = data[b];
        data[b] = tmp;
    }

歸并排序(MergeSort)

• 平均/最好/最差時間復(fù)雜度：O(nlogn)
• 平均空間復(fù)雜度：O(n)
• 穩(wěn)定性：穩(wěn)定
• 復(fù)雜度分析：
  歸并排序比較占用內(nèi)存，但卻是一種效率高且穩(wěn)定的算法。
• 代碼實(shí)現(xiàn)：

    void mergeSort(int[] data, int low, int high) {
        if (data == null || low < 0 || high >= data.length)
            throw new RuntimeException("Invalid Parameters!");

        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(data, low, mid);
            mergeSort(data, mid + 1, high);
            merge(data, low, mid, high);
        }
    }

    void merge(int[] data, int low, int mid, int high) {
        int startFrist = low, endFrist = mid, startSecond = mid + 1, endSecond = high;
        int[] tmp = new int[data.length];
        int i = startFrist, j = startSecond, index = startFrist;
        while (i <= endFrist && j <= endSecond)
            if (data[i] < data[j])
                tmp[index++] = data[i++];
            else
                tmp[index++] = data[j++];

        while (i <= endFrist)
            tmp[index++] = data[i++];

        while (j <= endSecond)
            tmp[index++] = data[j++];

        for (index = low; index <= high; index++)
            data[index] = tmp[index];
    }

二分查找

• 平均/最差時間復(fù)雜度：O(logn)
• 平均查找長度ASL：log2(n+1) - 1
• 空間復(fù)雜度：O(1)
• 算法分析：折半查找要求線性表是有序表。另外，由于折半查找需要確定查找的區(qū)間，所以只適用于順序存儲結(jié)構(gòu)，不適用于鏈?zhǔn)酱鎯Y(jié)構(gòu)。為保持順序表的有序，表的插入和刪除操作都需要移動大量元素，所以折半查找特別適用于一旦建立就很少改動，又經(jīng)常需要進(jìn)行查找的線性表。
• 實(shí)現(xiàn)代碼

    public BinarySearch(int[] data, int length, int key) {
        if (data == null || length <= 0)
            throw new RuntimeException("Invalid parameters");

        int low = 0, high = length - 1;
        while (low <= high) {               // 當(dāng)前區(qū)間存在元素時循環(huán)
            int mid = (low + high) / 2;
            if (data[mid] == key)           // 查找成功返回其邏輯序號mid+1
                return mid + 1;
            else if (data[mid] < key)       // 繼續(xù)在data[mid+1 .. high]中查找
                low = mid + 1;
            else
                high = mid - 1;               // 繼續(xù)在data[low .. mid-1]中查找
        }

        return 0;                           // 查找失敗返回0
    }

索引存儲結(jié)構(gòu)和分塊查找

1. 索引存儲結(jié)構(gòu)

索引存儲結(jié)構(gòu)是在存儲數(shù)據(jù)的同時，還建立附加的索引表。索引表中的每一項(xiàng)稱為索引項(xiàng)，索引項(xiàng)的結(jié)構(gòu)一般形式為（關(guān)鍵字，地址）。
關(guān)鍵字唯一標(biāo)識一個節(jié)點(diǎn)，地址是指向該關(guān)鍵字對應(yīng)節(jié)點(diǎn)的指針，也可以是相對地址。

• 索引存儲結(jié)構(gòu)的優(yōu)缺點(diǎn)
  • 優(yōu)點(diǎn)：線性結(jié)構(gòu)采用索引存儲后，可以對節(jié)點(diǎn)進(jìn)行隨機(jī)訪問。在進(jìn)行插入、刪除運(yùn)算時，由于只需要修改索引表中相關(guān)節(jié)點(diǎn)的存儲地址，而不必移動存儲在節(jié)點(diǎn)表中的節(jié)點(diǎn)，所以仍可保存較高的運(yùn)算效率。
  • 缺點(diǎn)：為了建立索引表需要增加時間和空間的開銷。

2. 分塊查找

分塊查找又稱索引順序查找，它是一種性能介于順序查找和二分查找之間的查找方法。
分塊查找需要按照如下的索引方式建立存儲線性表：將表R[0.. n-1]均分為b塊，前b-1塊中元素個數(shù)為s=?n/b?，最后一塊即第b塊的元素個數(shù)等于或小于s；每一塊的關(guān)鍵字不一定有序，但是前一塊中的最大關(guān)鍵字必須小于后一塊中的最小關(guān)鍵字，即要求表是“分塊有序”的。
分塊查找的基本思路是：首先查找索引表，因?yàn)樗饕硎怯行虮?，故可以用折半查找或順序查找，以確定待查的元素在哪一塊；然后在已確定的塊中進(jìn)行順序查找（因塊內(nèi)元素?zé)o序，只能用順序查找）。

• 采用折半查找來確定塊元素所在塊的平均查找長度ASL：log2(b+1) + s/2，s越小，即每塊長度越小越好
• 采用順序查找來確定塊元素所在塊的平均查找長度ASL：(b+s)/2 + 1，s=√￣n時，ASL取極小值√￣n+1，即采用順序查找確定塊時，各塊元素個數(shù)取√￣n最佳。
• 分塊查找的缺點(diǎn)：增加一個索引表的存儲空間和建立索引表的時間。

冒泡排序（BubbleSort）

• 平均/最差時間復(fù)雜度：O(n^2)
• 最好時間復(fù)雜度：O(n)
• 平均空間復(fù)雜度：O(1)
• 穩(wěn)定性：穩(wěn)定
• 算法思想：
  從最下面的元素開始，對每兩個相鄰的元素的關(guān)鍵字進(jìn)行比較，且使關(guān)鍵字小的元素?fù)Q至關(guān)鍵字大的元素之上，使得一趟排序后，關(guān)鍵字最小的元素到達(dá)最上端。
• 代碼實(shí)現(xiàn)：

    void bubbleSort(int[] data, int length) {
        if (data == null || length <= 0) 
            throw new RuntimeException("Invalid Paramemers");
        
        for (int i = 0; i < length-1; i++) {
            boolean isExchange = false;
            for (int j = length-1; j > i; j--) {
                if (data[j] < data[j-1]) {
                    swap(data, j, j-1);
                    isExchange = true;
                }
            }
            if(!isExchange)
                return;
        }
    }

選擇排序（SelectSort）

• 平均/最好/最差時間復(fù)雜度：O(n^2)
• 空間復(fù)雜度：O(1)
• 穩(wěn)定性：不穩(wěn)定
• 性能分析：適用于從大量元素中選擇一部分排序元素，例如從1w個元素中找出前10個元素
• 排序思路
  第i趟排序開始時，R[0 .. i-1]是有序區(qū)，而R[i .. n-1]是無序區(qū)。該趟排序是從當(dāng)前無序區(qū)中選出關(guān)鍵字最小的元素R[k]，將它和無序區(qū)的第一個元素R[i]交換，使得R[0.. i]和R[i+1 .. n-1]變成新的有序區(qū)和新的無序區(qū)。
• 代碼實(shí)現(xiàn)：

    void selectSort(int[] data, int length) {
        if (data == null || length <= 0) 
            throw new RuntimeException("Invalid Paramemers");
        
        for (int i = 0; i < length-1; i++) {
            int minIndex = i;
            for (int j = i+1; j < length; j++) 
                if (data[j] < data[minIndex]) 
                    minIndex = j;
            if (minIndex != i) 
                swap(data, minIndex, i);
        }
    }

堆排序（heapSort）

• 平均/最好/最差時間復(fù)雜度：O(nlogn)
• 空間復(fù)雜度：O(1)
• 穩(wěn)定性：不穩(wěn)定
• 性能分析：由于建初始堆所需的比較次數(shù)較多，所以堆排序不適宜于記錄數(shù)較少的文件。
• 排序思路：
  堆排序是一種樹形選擇排序方法，在排序過程中，將data[1 .. n]看成一顆完全二叉樹的順序存儲結(jié)構(gòu)，利用完全二叉樹中雙親節(jié)點(diǎn)和孩子節(jié)點(diǎn)之間的內(nèi)在關(guān)系，在當(dāng)前無序區(qū)中選擇關(guān)鍵字最大（或最小）的元素。
• 代碼實(shí)現(xiàn)：

    void heapSort(int[] data, int length) { // 為了與二叉樹的順序存儲結(jié)構(gòu)一致，堆排序的數(shù)據(jù)序列的下標(biāo)從1開始
        if (data == null || length <= 0) 
            throw new RuntimeException("Invalid Paramemers");

        for (int i = length/2; i >= 1; i--)          //初始化堆
            sift(data, i, length);                   
        for (int i = length; i >=2; i--) {           //進(jìn)行n-1趟堆排序，每一趟堆排序的元素個數(shù)減1
            swap(data, i, 1);                        //將最后一個元素同當(dāng)前區(qū)間內(nèi)data[1]對換
            sift(data, 1, i-1);                      //篩選data[1]節(jié)點(diǎn)，得到i-1個節(jié)點(diǎn)的堆
        }
    }

    void sift(int[] data, int low, int high) {
        int i = low, j = 2 * i;                     //data[j]是data[i]的左孩子
        int tmp = data[i];

        while (j <= high) {
            if (j < high && data[j] < data[j + 1])  //若右孩子較大，把j指向右孩子
                j++;
            if (tmp < data[j]) {
                data[i] = data[j];                  //將data[j]調(diào)整到雙親節(jié)點(diǎn)位置上
                i = j;                              //修改i和j值，以便繼續(xù)向下篩選
                j = 2 * i;
            } else
                break;                              //篩選結(jié)束 
        }
        data[i] = tmp;                              //被篩選節(jié)點(diǎn)的值放入最終位置
    }

插入排序（InsertSort）

• 平均/最差時間復(fù)雜度：O(n^2)
• 最好時間復(fù)雜度：O(n)
• 空間復(fù)雜度：O(1)
• 穩(wěn)定性：穩(wěn)定
• 算法思想：
  每次將一個待排序元素，按其關(guān)鍵字大小插入到已經(jīng)排好序的子表中的恰當(dāng)位置，知道全部元素插入完成為止。
• 實(shí)現(xiàn)代碼：

    void insertSort(int[] data, int length) {
        if (data == null || length <= 0) 
            throw new RuntimeException("Invalid Paramemers");

        for (int i = 1; i < length; i++) {
            int tmp = data[i];
            int j = i-1;                      //從右向左在有序區(qū)data[0 .. i-1]中找data[i]的插入位置
            while (j >= 0 && data[j] > tmp) {
                data[j+1] = data[j];          //將大于data[i]的元素后移
                j--;
            }
            data[j+1] = tmp;
        }
    }

希爾排序（ShellSort）

• 平均時間復(fù)雜度：O(n^1.3)
• 空間復(fù)雜度：O(1)
• 穩(wěn)定性：不穩(wěn)定
• 算法分析：希爾排序和插入排序基本一致，為什么希爾排序的時間性能會比插入排序優(yōu)呢？直接插入排序在表初態(tài)為正序時所需時間最少，實(shí)際上，當(dāng)表初態(tài)基本有序時直接插入排序所需的比較和移動次數(shù)都比較少。另一方面，當(dāng)n值較小時，n和n^{2的差別也比較小，即直接插入排序的最好時間復(fù)雜度O(n)和最差時間復(fù)雜度O(n}2)差別也不大。在希爾排序開始時，增量d1較大，分組較多，每組的元素數(shù)目少，故各組內(nèi)直接插入排序較快，后來增量di逐漸縮小，分組數(shù)逐漸減少，而各組內(nèi)的元素數(shù)目逐漸增多，但由于已經(jīng)按di-1作為增量排過序，使表教接近有序狀態(tài)，所以新的一趟排序過程也較快。因此，希爾排序在效率上較直接插入排序有較大的改進(jìn)。
• 代碼實(shí)現(xiàn)：

    void shellSort(int[] data, int length) {
        int gap = length / 2;
        while (gap > 0) {
            for (int i = gap; i < length; i++) {
                int tmp = data[i];
                int j = i - gap;
                while (j >= 0 && tmp < data[j]) {
                    data[j + gap] = data[j];
                    j -= gap;
                }
                data[j + gap] = tmp;
            }
            gap /= 2;
        }
    }

基數(shù)排序（RadixSort）

• 平均/最好/最差時間復(fù)雜度：O(d(n+r))
• 空間復(fù)雜度：O(r)
• 穩(wěn)定性：穩(wěn)定
• 算法思想：
• 實(shí)現(xiàn)代碼：

    class Node{
        int num;
        Node next;
    }

    void RadixSort(Node p, int r, int d) {
        if (p == null || r <= 0 || d <= 0)
            throw new RuntimeException("Invalid Parameters");

        Node[] head = new Node[10];
        Node[] tail = new Node[10];
        Node t = null;
        for (int i = 0; i <= d - 1; i++) {
            t = p;
            for (int j = 0; j < r; j++)
                head[j] = tail[j] = null;

            while (p.next != null) {
                p = p.next;
                int k = getDigit(p.num, i);
                if (head[k] == null) {
                    head[k] = p;
                    tail[k] = p;
                } else {
                    tail[k].next = p;
                    tail[k] = p;
                }
            }

            p = t;
            p.next = null;
            for (int j = 0; j < r; j++)
                if (head[j] != null) {
                    if (p.next == null)
                        p.next = head[j];
                    else
                        t.next = head[j];
                    t = tail[j];
                }
            t.next = null;
        }
    }

    public static int getDigit(int x, int d) {
        int a[] = { 1, 10, 100 }; // 如果實(shí)例的最大數(shù)是百位數(shù)，那就只要到100就可以了
        return ((x / a[d]) % 10);
    }

各種內(nèi)排序方法的比較和總結(jié)

• 按平均時間復(fù)雜度將排序分為3類：

  1. 平方階O(n^2)排序，一般稱為簡單排序，例如直接插入排序，直接選擇排序和冒泡排序
  2. 線性對數(shù)階O(nlogn)排序，如快速排序、堆排序和歸并排序

  3. 線性階O(n)排序，如基數(shù)排序（假定數(shù)據(jù)的位數(shù)d和進(jìn)制r為常量時）

     
     
     各種排序方法的性能

• 因?yàn)椴煌判蚍椒ㄟm應(yīng)于不同的應(yīng)用環(huán)境和要求，所以選擇適合的排序方法應(yīng)綜合考慮下列因素：

  1. 待排序的元素數(shù)目n（問題規(guī)模）；
  2. 元素的大?。總€元素的規(guī)模）；
  3. 關(guān)鍵字的結(jié)構(gòu)及其初始狀態(tài)；
  4. 對穩(wěn)定性的要求；
  5. 語言工具的條件；
  6. 存儲結(jié)構(gòu)；
  7. 時間和空間復(fù)雜度等。

• 沒有一種排序方法是絕對好的。每一種排序方法都各有其優(yōu)缺點(diǎn)，適用于不同的環(huán)境。因此，在實(shí)際應(yīng)用中，應(yīng)根據(jù)具體情況做選擇。首先考慮排序?qū)Ψ€(wěn)定性的要求，若要求穩(wěn)定，則只能在穩(wěn)定方法中選取，否則可以在所有方法中選??；其次要考慮待排序節(jié)點(diǎn)數(shù)n的大小，若n較大，則可在改進(jìn)方法中選取，否則在簡單方法中選取；然后在考慮其他因素。綜合考慮以上幾點(diǎn)可以得出的大致結(jié)論：

  1. 若n較?。ㄈ鏽<=50），可采用直接插入排序或直接選擇排序。當(dāng)元素規(guī)模較小時，直接插入排序較好；否則因?yàn)橹苯舆x擇排序移動的元素少于直接插入排序，應(yīng)選直接選擇排序。
  2. 若文件初始狀態(tài)基本有序（指正序），則應(yīng)選用直接插入、冒泡或隨機(jī)的快速排序。
  3. 若n較大，則應(yīng)采用時間復(fù)雜度為O(nlogn)的排序方法：快速排序、堆排序或歸并排序?？焖倥判虮徽J(rèn)為是目前基于比較的內(nèi)部排序中較好的方法，當(dāng)待排序的關(guān)鍵字隨機(jī)分布時，快速排序的平均時間最短；但堆排序所需的輔助空間比快速排序少，并且不會出現(xiàn)快速排序可能出現(xiàn)的最壞情況。這兩種排序都是不穩(wěn)定的，若要求穩(wěn)定，則可選用歸并排序。
  4. 若要將兩個有序表合并成一個新的有序表，最好的方法是歸并排序。
  5. 在基于比較的排序方法中，至少是需要O(nlogn)的時間。而基數(shù)排序只需要一步就會引起r種可能的轉(zhuǎn)移，即把一個元素裝入r個隊(duì)列之一，因此一般情況下，基數(shù)排序可能在O(n)時間內(nèi)完成對n個元素的排序。但遺憾的是，基數(shù)排序只適用于像字符串和整數(shù)這類有明顯結(jié)構(gòu)特征的關(guān)鍵字，而當(dāng)關(guān)鍵字的取值范圍屬于某個無窮集合（例如實(shí)數(shù)型關(guān)鍵字）時，無法使用基數(shù)排序，這時只有借助于“比較”的方法來排序。由此可知，若n很大，元素的關(guān)鍵字位數(shù)較少且可以分解時，采用基數(shù)排序較好。