桶排序與基數排序

桶排序：限定場景在0-n 有數值範圍內一個無序數列a[k]，對無序數列進行分n+1個桶，而後從桶中比較獲取回來一個有序數列。

        排序方法：一、創建0-n數值的（n+1）一個桶，而後對無序數列中的a[k]等於對應桶（n）的數值進行累加統計  二、 遍歷整個桶，數值和桶對應編號（n）相等的進行賦值給新的數列，並對其桶統計值自減，直至爲0. 這樣得出來就是一個有序的數列。

桶排序舉個例子，有一個整數序列，0, 133, 45, 386, 106，45下面是排序過程：

一、首先計算出最大桶，最大桶是386；

二、對不一樣的桶進行統計，{1（桶編號0只有1個數值），0(桶編號爲1沒有數值,.................2（b編號45 含有2個數值）,..............1(編號386)}

三、最後對桶進行遍歷 ，桶含有值的 依次裝入 一個新的序列數組中{0, 45,45, 106, 133, 386} 完成排序

 

基數排序：核心思想是將整數按位數切割成不一樣的數字，而後按每一個位數分別比較。

      排序方法：好比有個數列{123,456，78}。咱們能夠經過獲取最大數值的位數，經過對不足的前面補0，而後對這個序列進行個位、十位、百位的0-9進行分桶 進行排序，最後得出來就是個有序數列。

     基數排序這兒思考一個問題，爲何將整數按位數進行切割後，按照位數進行排序，不使用冒泡、快速排序這些算法呢。認真想下，其實比較簡單，冒泡算法仍是快速排序原本就比桶排序比較來講，長的不少，按位數進行排序後，對其作冒泡排序，時間複雜度等於 K（總位數）* n*(n-1) ，比原來的冒泡排序還更復雜了，這樣還不如就直接使用冒泡排序就能夠直接一次完成排序，快速排序也有一樣差很少道理，桶排序就是由於時間效率遠遠大的多於好比冒泡、快速排序，因此其實這兒基數排序相對說是桶排序的一個折中 空間和時間複雜度的算法。

基數排序舉個例子，有一個整數序列，0, 133, 45, 386, 106，下面是排序過程：

第一次排序，個位，000 133 045 386 106，無任何變化
第二次排序，十位，000 106 133 045 386
第三次排序，百位，000 045 106 133 386
最終結果，0, 45, 106, 133, 386, 排序完成。
 

下面附桶排序和基數排序我的實現代碼：

private static int[] bucketSort(int[] array) {
        int max = 0; 
        for(int i=0;i<array.length;i++){
            if(max<array[i]){
                max= array[i];
            }
        }
        max += 1; //計算得出桶最大值，肯定最大桶
        int[] data = new int[array.length];
        int[] bucket = new int[max];
        for (int i = 0; i < array.length; i++) {//n
            bucket[array[i]]++; // 對數列中進行裝桶
        }
        int i = 0;
        int j = 0;

        while (i < max) {// 遍歷全部桶中含有 統計數值大於0的數值，進行有序裝載對應的數據，最後出來有序數列
            if (bucket[i] > 0) {
                while ((bucket[i]--) > 0) {
                    data[j++] = i;
                }
            }
            i++;
        }
        return data;
    }

//基數排序

public static void radixSort(int[] data) {
        int length = data.length;

        // 獲取指數的位數
        int count = getMaxCount(data, length); //獲取最大位數

        // 對各個位數進行排序

        int index = 0;//
        while (index < count) {
            data = bucketSort(data, index, count);
            index++;
        }

    }

 

    private static int getMaxCount(int[] data, int length) {
        int max = 0;
        for (int i = 0; i < length; i++) {
            if (data[i] > max) {
                max = data[i];
            }
        }
        int count = 1;
        int n = 10;
        while (max / n != 0) {// 1021 ,20
            n = n * 10;
            count++;
        }
        return count;
    }

//按位數進行桶排序

private static int[] bucketSort2(int[] array, int index, int count) {

        int bucketLength = 10;

        int multiNum = (int) Math.pow(10, index);
        int[] data = new int[array.length];
        int[] bucket = new int[bucketLength];
        int i;
        for (i = 0; i < array.length; i++) {// n
            // array 數據轉化爲到具體位數進行排序
            int temp = (array[i] / multiNum) % 10;
            bucket[temp]++;
        }

        for (i = 1; i < 10; i++) {
            bucket[i] += bucket[i - 1];
        }

        for (i = array.length - 1; i >= 0; i--) {
            data[bucket[(array[i] / multiNum) % 10] - 1] = array[i];
            bucket[(array[i] / multiNum) % 10]--;
        }

        for (i = 0; i < array.length; i++) {
            array[i] = data[i];
        }

        return array;
    }
    

    未完後面待續