計數排序，基數排序和桶排序

    計數排序，基數排序，桶排序等非比較排序算法，平均時間復雜度都是O(n)。這些排序因為其待排序元素本身就含有了定位特征，因而不需要比較就可以確定其前后位置，從而可以突破比較排序算法時間復雜度O(nlgn)的理論下限。

計數排序(Counting sort)

    計數排序(Counting sort)是一種穩定的排序算法。計數排序是最簡單的特例，由於用來計數的數組C的長度取決於待排序數組中數據的范圍（等於待排序數組的最大值與最小值的差加上1），這使得計數排序對於數據范圍很大的數組，需要大量時間和內存，適用性不高。例如：計數排序是用來排序0到100之間的數字的最好的算法，但是它不適合按字母順序排序人名。但是，計數排序可以用在基數排序中的算法來排序數據范圍很大的數組。當輸入的元素是 n 個 0 到 k 之間的整數時，它的運行時間是 Θ(n + k)。

    假定輸入是個數組A【1...n】， length【A】=n。 另外還需要一個存放排序結果的數組B【1...n】，以及提供臨時存儲區的C【0...k】(k是所有元素中最大的一個)。算法偽代碼：

算法的步驟如下：

1. 找出待排序的數組中最大和最小的元素
2. 統計數組中每個值為t的元素出現的次數，存入數組C的第t項
3. 對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）
4. 反向填充目標數組：將每個元素t放在新數組的第C(t)項，每放一個元素就將C(t)減去1

算法實現：

/*
 *  算法的步驟如下：
    1、找出待排序的數組中最大和最小的元素
    2、統計數組中每個值為t的元素出現的次數，存入數組C的第t項
    3、對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）
    4、反向填充目標數組：將每個元素t放在新數組的第C(t)項，每放一個元素就將C(t)減去1
 * */
public class CountingSort {
    // 類似bitmap排序
    public static void countSort(int[] a, int[] b, final int k) {
        // k>=n
        int[] c = new int[k + 1];
        for (int i = 0; i < k; i++) {
            c[i] = 0;
        }
        for (int i = 0; i < a.length; i++) {
            c[a[i]]++;
        }
        System.out.println("\n****************");
        System.out.println("計數排序第2步后,臨時數組C變為：");
        for (int m:c) {
            System.out.print(m + " ");
        }

        for (int i = 1; i <= k; i++) {
            c[i] += c[i - 1];
        }
        System.out.println("\n計數排序第3步后,臨時數組C變為：");
        for (int m:c) {
            System.out.print(m + " ");
        }

        for (int i = a.length - 1; i >= 0; i--) {
            b[c[a[i]] - 1] = a[i];//C[A[i]]-1 就代表小於等於元素A[i]的元素個數，就是A[i]在B的位置
            c[a[i]]--;
        }
        System.out.println("\n計數排序第4步后,臨時數組C變為：");
        for (int n:c) {
            System.out.print(n + " ");
        }
        System.out.println("\n計數排序第4步后,數組B變為：");
        for (int t:b) {
            System.out.print(t + " ");
        }
        System.out.println();
        System.out.println("****************\n");
    }

    public static int getMaxNumber(int[] a) {
        int max = 0;
        for (int i = 0; i < a.length; i++) {
            if (max < a[i]) {
                max = a[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        int[] a = new int[] { 2, 5, 3, 0, 2, 3, 0, 3 };
        int[] b = new int[a.length];
        System.out.println("計數排序前為：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
        countSort(a, b, getMaxNumber(a));
        System.out.println("計數排序后為：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(b[i] + " ");
        }
        System.out.println();
    }

}

 

基數排序(radix sorting)

      基數排序（radix sorting）將所有待比較數值(正整數)統一為同樣的數位長度，數位較短的數前面補零。 然后 從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后， 數列就變成一個有序序列。具體過程可以參考動畫演示。

     假設我們有一些二元組(a,b)，要對它們進行以a為首要關鍵字，b的次要關鍵字的排序。我們可以先把它們先按照首要關鍵字排序，分成首要關鍵字相同的若干堆。然后，在按照次要關鍵值分別對每一堆進行單獨排序。最后再把這些堆串連到一起，使首要關鍵字較小的一堆排在上面。按這種方式的基數排序稱為MSD(Most Significant Dight)排序。第二種方式是從最低有效關鍵字開始排序，稱為LSD(Least Significant Dight)排序。首先對所有的數據按照次要關鍵字排序，然后對所有的數據按照首要關鍵字排序。要注意的是，使用的排序算法必須是穩定的，否則就會取消前一次排序的結果。由於不需要分堆對每堆單獨排序，LSD方法往往比MSD簡單而開銷小。下文介紹的方法全部是基於LSD的。

      基數排序的簡單描述就是將數字拆分為個位十位百位，每個位依次排序。因為這對算法穩定要求高，所以我們對數位排序用到上一個排序方法計數排序。因為基數排序要經過d (數據長度)次排序， 每次使用計數排序， 計數排序的復雜度為 On),  d 相當於常量和N無關，所以基數排序也是 O(n)。基數排序雖然是線性復雜度， 即對n個數字處理了n次，但是每一次代價都比較高， 而且使用計數排序的基數排序不能進行原地排序，需要更多的內存， 並且快速排序可能更好地利用硬件的緩存， 所以比較起來，像快速排序這些原地排序算法更可取。對於一個位數有限的十進制數，我們可以把它看作一個多元組，從高位到低位關鍵字重要程度依次遞減。可以使用基數排序對一些位數有限的十進制數排序。

    例如我們將一個三位數分成，個位，十位，百位三部分。我們要對七個三位數來進行排序，依次對其個位，十位，百位進行排序，如下圖：

很顯然，每一位的數的大小都在[0，9]中，對於每一位的排序用計數排序再適合不過。

算法實現：

// 基數排序：穩定排序
public class RadixSorting {

    // d為數據長度
    private static void radixSorting(int[] arr, int d) {
        //arr = countingSort(arr, 0);
        for (int i = 0; i < d; i++) {
            arr = countingSort(arr, i); // 依次對各位數字排序（直接用計數排序的變體）
            print(arr,i+1,d);
        }
    }

    // 把每次按位排序的結果打印出來
    static void print(int[] arr,int k,int d)
    {
        if(k==d)
            System.out.println("最終排序結果為：");
        else
            System.out.println("按第"+k+"位排序后，結果為：");
        for (int t : arr) {
            System.out.print(t + " ");
        }
        System.out.println();
    }

    // 利用計數排序對元素的每一位進行排序
    private static int[] countingSort(int[] arr, int index) {
        int k = 9;
        int[] b = new int[arr.length];
        int[] c = new int[k + 1]; //這里比較特殊：數的每一位最大數為9

        for (int i = 0; i < k; i++) {
            c[i] = 0;
        }
        for (int i = 0; i < arr.length; i++) {
            int d = getBitData(arr[i], index);
            c[d]++;
        }
        for (int i = 1; i <= k; i++) {
            c[i] += c[i - 1];
        }
        for (int i = arr.length - 1; i >= 0; i--) {
            int d = getBitData(arr[i], index);
            b[c[d] - 1] = arr[i];//C[d]-1 就代表小於等於元素d的元素個數，就是d在B的位置
            c[d]--;
        }
        return b;
    }

    // 獲取data指定位的數
    private static int getBitData(int data, int index) {
        while (data != 0 && index > 0) {
            data /= 10;
            index--;
        }
        return data % 10;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = new int[] {326,453,608,835,751,435,704,690,88,79,79};//{ 333, 956, 175, 345, 212, 542, 99, 87 };
        System.out.println("基數排序前為：");
        for (int t : arr) {
            System.out.print(t + " ");
        }
        System.out.println();
        radixSorting(arr, 4);
    }

}

 

桶排序（Bucket Sort）

    首先定義桶，桶為一個數據容器，每個桶存儲一個區間內的數。依然有一個待排序的整數序列A，元素的最小值不小於0，最大值不超過K。假設我們有M個桶，第i個桶Bucket[i]存儲i*K/M至(i+1)*K/M之間的數。桶排序步驟如下：

1. 掃描序列A，根據每個元素的值所屬的區間，放入指定的桶中(順序放置)。
2. 對每個桶中的元素進行排序，什么排序算法都可以，例如插入排序。
3. 依次收集每個桶中的元素，順序放置到輸出序列中。

     具體過程可以參考動畫演示。

算法偽代碼為：

具體代碼：

 

// 桶排序
public class BucketSort {

    // 插入排序
    static void insertSort(int[] a) {
        int n = a.length;
        for (int i = 1; i < n; i++) {
            int p = a[i];
            insert(a, i, p);
        }
    }

    static void insert(int[] a, int index, int x) {
        // 元素插入數組a[0:index-1]
        int i;
        for (i = index - 1; i >= 0 && x < a[i]; i--) {
            a[i + 1] = a[i];
        }
        a[i + 1] = x;
    }

    private static void bucketSort(int[] a) {
        int M = 10; // 11個桶
        int n = a.length;
        int[] bucketA = new int[M]; // 用於存放每個桶中的元素個數
        // 構造一個二維數組b，用來存放A中的數據,這里的B相當於很多桶，B[i][]代表第i個桶
        int[][] b = new int[M][n];
        int i, j;
        for (i = 0; i < M; i++)
            for (j = 0; j < n; j++)
                b[i][j] = 0;

        int data, bucket;
        for (i = 0; i < n; i++) {
            data = a[i];
            bucket = data / 10;
            b[bucket][bucketA[bucket]] = a[i];// B[0][]中存放A中進行A[i]/10運算后高位為0的數據，同理B[1][]存放高位為1的數據
            bucketA[bucket]++;// 用來計數二維數組中列中數據的個數，也就是桶A[i]中存放數據的個數
        }
        System.out.println("每個桶內元素個數：");
        for (i = 0; i < M; i++) {
            System.out.print(bucketA[i] + " ");
        }
        System.out.println();

        System.out.println("數據插入桶后，桶內未進行排序前的結果為：");
        for (i = 0; i < M; i++) {
            for (j = 0; j < n; j++)
                System.out.print(b[i][j] + " ");
            System.out.println();
        }

        System.out.println("對每個桶進行插入排序，結果為：");
        // 下面使用直接插入排序對這個二維數組進行排序,也就是對每個桶進行排序
        for (i = 0; i < M; i++) {
            // 下面是對具有數據的一列進行直接插入排序，也就是對B[i][]這個桶中的數據進行排序
            if (bucketA[i] != 0) {
                // 插入排序
                for (j = 1; j < bucketA[i]; j++) {
                    int p = b[i][j];
                    int k;
                    for (k = j - 1; k >= 0 && p < b[i][k]; k--)
                    {
                        assert k==-1;
                        b[i][k + 1] = b[i][k];
                    }
                    b[i][k + 1] = p;
                }
            }
        }

        // 輸出排序過后的順序
        for (i = 0; i < 10; i++) {
            if (bucketA[i] != 0) {
                for (j = 0; j < bucketA[i]; j++) {
                    System.out.print(b[i][j] + " ");
                }
            }
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = new int[] {3,5,45,34,2,78,67,34,56,98};
        bucketSort(arr);
    }

}

三種線性排序的比較

排序算法	時間復雜度	空間復雜度
計數排序	O(N+K)	O(N+K)	穩定排序
基數排序	O(N)	O(N)	穩定排序
桶排序	O(N+K)	O(N+K)	穩定排序

     從整體上來說，計數排序，桶排序都是非基於比較的排序算法，而其時間復雜度依賴於數據的范圍，桶排序還依賴於空間的開銷和數據的分布。而基數排序是一種對多元組排序的有效方法，具體實現要用到計數排序或桶排序。

     相對於快速排序、堆排序等基於比較的排序算法，計數排序、桶排序和基數排序限制較多，不如快速排序、堆排序等算法靈活性好。但反過來講，這三種線性排序算法之所以能夠達到線性時間，是因為充分利用了待排序數據的特性，如果生硬得使用快速排序、堆排序等算法，就相當於浪費了這些特性，因而達不到更高的效率。

參考資料

http://www.cnblogs.com/bluedream2009/archive/2011/04/14/2016551.html

http://www.byvoid.com/blog/sort-radix/