java實現基數排序

基數排序(桶排序)介紹:

1)基數排序（radix sort）屬於“分配式排序”（distribution sort），又稱“桶子法”（bucket sort）或bin sort，顧名思義，它是通過鍵值的各個位的值，將要排序的元素分配至某些“桶”中，達到排序的作用

2)基數排序法是屬於穩定性的排序，基數排序法的是效率高的穩定性排序法

3)基數排序(Radix Sort)是桶排序的擴展

4)基數排序是1887年赫爾曼·何樂禮發明的。它是這樣實現的：將整數按位數切割成不同的數字，然後按每個位數分別比較。

基數排序基本思想

1)將所有待比較數值統一爲同樣的數位長度，數位較短的數前面補零。然後，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以後, 數列就變成一個有序序列。

2)這樣說明，比較難理解，下面我們看一個圖文解釋，理解基數排序的步驟

基數排序圖文說明

將數組 {53, 3, 542, 748, 14, 214} 使用基數排序, 進行升序排序。

代碼實現 

public class RadixSort {

    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        radixSort2(arr);
    }


    public static void radixSort(int[] arr){
        /**
         * 定義一個二維數組，表示10個桶，每個桶就是一個一維數組
         * 爲了防止放入數據時候，數據溢出，則每個一維數組，大小定爲 arr.length
         */
        int[][] bucket = new int[10][arr.length];

        //爲了記錄每個桶中存放數據的個數
        int[] bucketElementCounts = new int[10];
        //第1輪 針對每個元素的個位進行排序
        for (int j = 0; j < arr.length ; j++){
            int digitOfElement = arr[j] /1 % 10;//取出每個元素的個位的值
            //放入到對應的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        int index = 0;
        //遍歷每一個桶，將桶中的數據存放到原數組中
        for(int k = 0 ; k < bucketElementCounts.length ; k++){
            //判斷桶中是否有數據
            if(bucketElementCounts[k] != 0){
                //循環第k個桶
                for(int l = 0 ; l < bucketElementCounts[k] ; l++){
                    //取出數據放入arr
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }
        System.out.println("第1輪，對個位排序後數據 arr=" + Arrays.toString(arr));

        //======================================================

        //第2輪 針對每個元素的十位進行排序
        for (int j = 0; j < arr.length ; j++){
            int digitOfElement = arr[j] / 10 % 10;//取出每個元素的個位的值
            //放入到對應的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        index = 0;
        //遍歷每一個桶，將桶中的數據存放到原數組中
        for(int k = 0 ; k < bucketElementCounts.length ; k++){
            //判斷桶中是否有數據
            if(bucketElementCounts[k] != 0){
                //循環第k個桶
                for(int l = 0 ; l < bucketElementCounts[k] ; l++){
                    //取出數據放入arr
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }
        System.out.println("第2輪，對十位排序後數據 arr=" + Arrays.toString(arr));

        //=======================================================
        //第3輪 針對每個元素的百位進行排序
        for (int j = 0; j < arr.length ; j++){
            int digitOfElement = arr[j] / 100 % 10;//取出每個元素的個位的值
            //放入到對應的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        index = 0;
        //遍歷每一個桶，將桶中的數據存放到原數組中
        for(int k = 0 ; k < bucketElementCounts.length ; k++){
            //判斷桶中是否有數據
            if(bucketElementCounts[k] != 0){
                //循環第k個桶
                for(int l = 0 ; l < bucketElementCounts[k] ; l++){
                    //取出數據放入arr
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }
        System.out.println("第3輪，對百位排序後數據 arr=" + Arrays.toString(arr));
    }

    public static void radixSort2(int[] arr){
        int max = arr[0];
        //得到數組中位數最大的數
        for (int i = 1 ; i < arr.length ; i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        int maxLength = (max + "").length();
        /**
         * 定義一個二維數組，表示10個桶，每個桶就是一個一維數組
         * 爲了防止放入數據時候，數據溢出，則每個一維數組，大小定爲 arr.length
         */
        int[][] bucket = new int[10][arr.length];

        //爲了記錄每個桶中存放數據的個數
        int[] bucketElementCounts = new int[10];

        for (int i = 0 ,n = 1; i < maxLength ; i++ ,n *= 10){
            for (int j = 0; j < arr.length ; j++){
                int digitOfElement = arr[j] /n % 10;//取出每個元素的個位的值
                //放入到對應的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            int index = 0;
            //遍歷每一個桶，將桶中的數據存放到原數組中
            for(int k = 0 ; k < bucketElementCounts.length ; k++){
                //判斷桶中是否有數據
                if(bucketElementCounts[k] != 0){
                    //循環第k個桶
                    for(int l = 0 ; l < bucketElementCounts[k] ; l++){
                        //取出數據放入arr
                        arr[index] = bucket[k][l];
                        index++;
                    }
                }
                bucketElementCounts[k] = 0;
            }
            System.out.println("第"+(i+1)+"輪，對個位排序後數據 arr=" + Arrays.toString(arr));
        }
    }

}

運行結果

基數排序的說明:

1)基數排序是對傳統桶排序的擴展，速度很快.

2)基數排序是經典的空間換時間的方式，佔用內存很大, 當對海量數據排序時，容易造成 OutOfMemoryError 。

3)基數排序時穩定的。[注:假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的相對次序保持不變，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序後的序列中，r[i]仍在r[j]之前，則稱這種排序算法是穩定的；否則稱爲不穩定的]

4)有負數的數組，我們不用基數排序來進行排序, 如果要支持負數，參考: https://code.i-harness.com/zh-CN/q/e98fa9