面試中的 10 大排序算法總結

時間  2019-11-07
標籤 面試 排序算法 總結 欄目 快樂工作 简体版
原文   原文鏈接

前言

查找和排序算法是算法的入門知識，其經典思想能夠用於不少算法當中。由於其實現代碼較短，應用較常見。因此在面試中常常會問到排序算法及其相關的問題。但萬變不離其宗，只要熟悉了思想，靈活運用也不是難事。通常在面試中最常考的是快速排序和歸併排序，而且常常有面試官要求現場寫出這兩種排序的代碼。對這兩種排序的代碼必定要信手拈來才行。還有插入排序、冒泡排序、堆排序、基數排序、桶排序等。面試官對於這些排序可能會要求比較各自的優劣、各類算法的思想及其使用場景。還有要會分析算法的時間和空間複雜度。一般查找和排序算法的考察是面試的開始，若是這些問題回答很差，估計面試官都沒有繼續面試下去的興趣都沒了。因此想開個好頭就要把常見的排序算法思想及其特色要熟練掌握，有必要時要熟練寫出代碼。html

接下來咱們就分析一下常見的排序算法及其使用場景。限於篇幅，某些算法的詳細演示和圖示請自行尋找詳細的參考。面試

冒泡排序

冒泡排序是最簡單的排序之一了，其大致思想就是經過與相鄰元素的比較和交換來把小的數交換到最前面。這個過程相似於水泡向上升同樣，所以而得名。舉個栗子，對5,3,8,6,4這個無序序列進行冒泡排序。首先從後向前冒泡，4和6比較，把4交換到前面，序列變成5,3,8,4,6。同理4和8交換，變成5,3,4,8,6,3和4無需交換。5和3交換，變成3,5,4,8,6,3.這樣一次冒泡就完了，把最小的數3排到最前面了。對剩下的序列依次冒泡就會獲得一個有序序列。冒泡排序的時間複雜度爲O(n^2)。算法

實現代碼：shell

/**
 *@Description:<p>冒泡排序算法實現</p>
 *@author 王旭
 *@time 2016-3-3 下午8:54:27
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        for(int i=0; i<arr.length-1; i++) {
            for(int j=arr.length-1; j>i; j--) {
                if(arr[j] < arr[j-1]) {
                    swap(arr, j-1, j);
                }
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
複製代碼

選擇排序

選擇排序的思想其實和冒泡排序有點相似，都是在一次排序後把最小的元素放到最前面。可是過程不一樣，冒泡排序是經過相鄰的比較和交換。而選擇排序是經過對總體的選擇。舉個栗子，對5,3,8,6,4這個無序序列進行簡單選擇排序，首先要選擇5之外的最小數來和5交換，也就是選擇3和5交換，一次排序後就變成了3,5,8,6,4.對剩下的序列一次進行選擇和交換，最終就會獲得一個有序序列。其實選擇排序能夠當作冒泡排序的優化，由於其目的相同，只是選擇排序只有在肯定了最小數的前提下才進行交換，大大減小了交換的次數。選擇排序的時間複雜度爲O(n^2)數組

實現代碼：bash

/**
 *@Description:<p>簡單選擇排序算法的實現</p>
 *@author 王旭
 *@time 2016-3-3 下午9:13:35
 */
public class SelectSort {

    public static void selectSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        int minIndex = 0;
        for(int i=0; i<arr.length-1; i++) { //只須要比較n-1次
            minIndex = i;
            for(int j=i+1; j<arr.length; j++) { //從i+1開始比較，由於minIndex默認爲i了，i就不必比了。
                if(arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }

            if(minIndex != i) { //若是minIndex不爲i，說明找到了更小的值，交換之。
                swap(arr, i, minIndex);
            }
        }

    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}
複製代碼

插入排序

插入排序不是經過交換位置而是經過比較找到合適的位置插入元素來達到排序的目的的。相信你們都有過打撲克牌的經歷，特別是牌數較大的。在分牌時可能要整理本身的牌，牌多的時候怎麼整理呢？就是拿到一張牌，找到一個合適的位置插入。這個原理其實和插入排序是同樣的。舉個栗子，對5,3,8,6,4這個無序序列進行簡單插入排序，首先假設第一個數的位置時正確的，想一下在拿到第一張牌的時候，不必整理。而後3要插到5前面，把5後移一位，變成3,5,8,6,4.想一下整理牌的時候應該也是這樣吧。而後8不用動，6插在8前面，8後移一位，4插在5前面，從5開始都向後移一位。注意在插入一個數的時候要保證這個數前面的數已經有序。簡單插入排序的時間複雜度也是O(n^2)。數據結構

實現代碼：函數

/** *@Description:<p>簡單插入排序算法實現</p> *@author 王旭 *@time 2016-3-3 下午9:38:55 */
public class InsertSort {

    public static void insertSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;

        for(int i=1; i<arr.length; i++) { //假設第一個數位置時正確的；要日後移，必需要假設第一個。

            int j = i;
            int target = arr[i]; //待插入的

            //後移
            while(j > 0 && target < arr[j-1]) {
                arr[j] = arr[j-1];
                j --;
            }

            //插入 
            arr[j] = target;
        }

    }

}
複製代碼

快速排序

快速排序一聽名字就以爲很高端，在實際應用當中快速排序確實也是表現最好的排序算法。冒泡排序雖然高端，但其實其思想是來自冒泡排序，冒泡排序是經過相鄰元素的比較和交換把最小的冒泡到最頂端，而快速排序是比較和交換小數和大數，這樣一來不只把小數冒泡到上面同時也把大數沉到下面。性能

舉個栗子：對5,3,8,6,4這個無序序列進行快速排序，思路是右指針找比基準數小的，左指針找比基準數大的，交換之。大數據

5,3,8,6,4 用5做爲比較的基準，最終會把5小的移動到5的左邊，比5大的移動到5的右邊。

5,3,8,6,4 首先設置i,j兩個指針分別指向兩端，j指針先掃描（思考一下爲何？）4比5小中止。而後i掃描，8比5大中止。交換i,j位置。

5,3,4,6,8 而後j指針再掃描，這時j掃描4時兩指針相遇。中止。而後交換4和基準數。

4,3,5,6,8 一次劃分後達到了左邊比5小，右邊比5大的目的。以後對左右子序列遞歸排序，最終獲得有序序列。

上面留下來了一個問題爲何必定要j指針先動呢？首先這也不是絕對的，這取決於基準數的位置，由於在最後兩個指針相遇的時候，要交換基準數到相遇的位置。通常選取第一個數做爲基準數，那麼就是在左邊，因此最後相遇的數要和基準數交換，那麼相遇的數必定要比基準數小。因此j指針先移動才能先找到比基準數小的數。

快速排序是不穩定的，其時間平均時間複雜度是O(nlgn)。

實現代碼：

/** *@Description:<p>實現快速排序算法</p> *@author 王旭 *@time 2016-3-3 下午5:07:29 */
public class QuickSort {
    //一次劃分
    public static int partition(int[] arr, int left, int right) {
        //一次劃分的邏輯，快排的子問題的劃分的邏輯和此相同，因此封裝爲一個函數
        int pivotKey = arr[left];
        int pivotPointer = left;

        while(left < right) {
            while(left < right && arr[right] >= pivotKey)
                right --;
            while(left < right && arr[left] <= pivotKey)
                left ++;
            swap(arr, left, right); //把大的交換到右邊，把小的交換到左邊。
        }
        swap(arr, pivotPointer, left); //最後把pivot交換到中間
        return left;
    }

    public static void quickSort(int[] arr, int left, int right) {
        // 遞歸的邊界條件
        if(left >= right)
            return ;
        int pivotPos = partition(arr, left, right);
        quickSort(arr, left, pivotPos-1);
        quickSort(arr, pivotPos+1, right);
    }
	// 這個函數是快排的封裝，使得函數對於使用者來講更加友好 
    public static void sort(int[] arr) {
        // 這是無效輸入而不是遞歸的邊界條件
        if(arr == null || arr.length == 0)
            return ;
        quickSort(arr, 0, arr.length-1);
    }

    public static void swap(int[] arr, int left, int right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }

}
複製代碼

其實上面的代碼還能夠再優化，上面代碼中基準數已經在pivotKey中保存了，因此不須要每次交換都設置一個temp變量，在交換左右指針的時候只須要前後覆蓋就能夠了。這樣既能減小空間的使用還能下降賦值運算的次數。優化代碼以下：

/**
 *@Description:<p>實現快速排序算法·
 *@author 王旭
 *@time 2016-3-3 下午5:07:29
 */
public class QuickSort {

    /**
     * 劃分
     * @param arr
     * @param left
     * @param right
     * @return
     */
    public static int partition(int[] arr, int left, int right) {
        int pivotKey = arr[left];

        while(left < right) {
            while(left < right && arr[right] >= pivotKey)
                right --;
            arr[left] = arr[right]; //把小的移動到左邊
            while(left < right && arr[left] <= pivotKey)
                left ++;
            arr[right] = arr[left]; //把大的移動到右邊
        }
        arr[left] = pivotKey; //最後把pivot賦值到中間
        return left;
    }

    /**
     * 遞歸劃分子序列
     * @param arr
     * @param left
     * @param right
     */
    public static void quickSort(int[] arr, int left, int right) {
        if(left >= right)
            return ;
        int pivotPos = partition(arr, left, right);
        quickSort(arr, left, pivotPos-1);
        quickSort(arr, pivotPos+1, right);
    }

    public static void sort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        quickSort(arr, 0, arr.length-1);
    }

}
複製代碼

總結快速排序的思想：冒泡+二分+遞歸分治，慢慢體會。

堆排序

堆排序是藉助堆來實現的選擇排序，思想同簡單的選擇排序，如下以大頂堆爲例。注意：若是想升序排序就使用大頂堆，反之使用小頂堆。緣由是堆頂元素須要交換到序列尾部。

首先，實現堆排序須要解決兩個問題：

\1. 如何由一個無序序列鍵成一個堆？

\2. 如何在輸出堆頂元素以後，調整剩餘元素成爲一個新的堆？

第一個問題，能夠直接使用線性數組來表示一個堆，由初始的無序序列建成一個堆就須要自底向上從第一個非葉元素開始挨個調整成一個堆。

第二個問題，怎麼調整成堆？首先是將堆頂元素和最後一個元素交換。而後比較當前堆頂元素的左右孩子節點，由於除了當前的堆頂元素，左右孩子堆均知足條件，這時須要選擇當前堆頂元素與左右孩子節點的較大者（大頂堆）交換，直至葉子節點。咱們稱這個自堆頂自葉子的調整成爲篩選。

從一個無序序列建堆的過程就是一個反覆篩選的過程。若將此序列當作是一個徹底二叉樹，則最後一個非終端節點是n/2取底個元素，由此篩選便可。舉個栗子：

49,38,65,97,76,13,27,49序列的堆排序建初始堆和調整的過程以下：

img

img

實現代碼：

/**
 *@Description:<p>堆排序算法的實現，以大頂堆爲例。</p>
 *@author 王旭
 *@time 2016-3-4 上午9:26:02
 */
public class HeapSort {

    /**
     * 堆篩選，除了start以外，start~end均知足大頂堆的定義。
     * 調整以後start~end稱爲一個大頂堆。
     * @param arr 待調整數組
     * @param start 起始指針
     * @param end 結束指針
     */
    public static void heapAdjust(int[] arr, int start, int end) {
        int temp = arr[start];

        for(int i=2*start+1; i<=end; i*=2) {
            //左右孩子的節點分別爲2*i+1,2*i+2

            //選擇出左右孩子較小的下標
            if(i < end && arr[i] < arr[i+1]) {
                i ++; 
            }
            if(temp >= arr[i]) {
                break; //已經爲大頂堆，=保持穩定性。
            }
            arr[start] = arr[i]; //將子節點上移
            start = i; //下一輪篩選
        }

        arr[start] = temp; //插入正確的位置
    }

    public static void heapSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;

        //創建大頂堆
        for(int i=arr.length/2; i>=0; i--) {
            heapAdjust(arr, i, arr.length-1);
        }

        for(int i=arr.length-1; i>=0; i--) {
            swap(arr, 0, i);
            heapAdjust(arr, 0, i-1);
        }

    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}
複製代碼

希爾排序

希爾排序是插入排序的一種高效率的實現，也叫縮小增量排序。簡單的插入排序中，若是待排序列是正序時，時間複雜度是O(n)，若是序列是基本有序的，使用直接插入排序效率就很是高。希爾排序就利用了這個特色。基本思想是：先將整個待排記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄基本有序時再對全體記錄進行一次直接插入排序。

舉個栗子：

img

從上述排序過程可見，希爾排序的特色是，子序列的構成不是簡單的逐段分割，而是將某個相隔某個增量的記錄組成一個子序列。如上面的例子，第一堂排序時的增量爲5，第二趟排序的增量爲3。因爲前兩趟的插入排序中記錄的關鍵字是和同一子序列中的前一個記錄的關鍵字進行比較，所以關鍵字較小的記錄就不是一步一步地向前挪動，而是跳躍式地往前移，從而使得進行最後一趟排序時，整個序列已經作到基本有序，只要做記錄的少許比較和移動便可。所以希爾排序的效率要比直接插入排序高。

希爾排序的分析是複雜的，時間複雜度是所取增量的函數，這涉及一些數學上的難題。可是在大量實驗的基礎上推出當n在某個範圍內時，時間複雜度能夠達到O(n^1.3)。

實現代碼：

/**
 *@Description:<p>希爾排序算法實現</p>
 *@author 王旭
 *@time 2016-3-3 下午10:53:55
 */
public class ShellSort {

    /**
     * 希爾排序的一趟插入
     * @param arr 待排數組
     * @param d 增量
     */
    public static void shellInsert(int[] arr, int d) {
        for(int i=d; i<arr.length; i++) {
            int j = i - d;
            int temp = arr[i];    //記錄要插入的數據  
            while (j>=0 && arr[j]>temp) {  //從後向前，找到比其小的數的位置   
                arr[j+d] = arr[j];    //向後挪動  
                j -= d;  
            }  

            if (j != i - d)    //存在比其小的數 
                arr[j+d] = temp;

        }
    }

    public static void shellSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        int d = arr.length / 2;
        while(d >= 1) {
            shellInsert(arr, d);
            d /= 2;
        }
    }

}
複製代碼

歸併排序

歸併排序是另外一種不一樣的排序方法，由於歸併排序使用了遞歸分治的思想，因此理解起來比較容易。其基本思想是，先遞歸劃分子問題，而後合併結果。把待排序列當作由兩個有序的子序列，而後合併兩個子序列，而後把子序列當作由兩個有序序列。。。。。倒着來看，其實就是先兩兩合併，而後四四合並。。。最終造成有序序列。空間複雜度爲O(n)，時間複雜度爲O(nlogn)。

舉個栗子：

img

實現代碼：

/**
 *@Description:<p>歸併排序算法的實現</p>
 *@author 王旭
 *@time 2016-3-4 上午8:14:20
 */
public class MergeSort {

    public static void mergeSort(int[] arr) {
        mSort(arr, 0, arr.length-1);
    }

    /**
     * 遞歸分治
     * @param arr 待排數組
     * @param left 左指針
     * @param right 右指針
     */
    public static void mSort(int[] arr, int left, int right) {
        if(left >= right)
            return ;
        int mid = (left + right) / 2;

        mSort(arr, left, mid); //遞歸排序左邊
        mSort(arr, mid+1, right); //遞歸排序右邊
        merge(arr, left, mid, right); //合併
    }

    /**
     * 合併兩個有序數組
     * @param arr 待合併數組
     * @param left 左指針
     * @param mid 中間指針
     * @param right 右指針
     */
    public static void merge(int[] arr, int left, int mid, int right) {
        //[left, mid] [mid+1, right]
        int[] temp = new int[right - left + 1]; //中間數組

        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right) {
            if(arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            }
            else {
                temp[k++] = arr[j++];
            }
        }

        while(i <= mid) {
            temp[k++] = arr[i++];
        }

        while(j <= right) {
            temp[k++] = arr[j++];
        }

        for(int p=0; p<temp.length; p++) {
            arr[left + p] = temp[p];
        }

    }
}
複製代碼

計數排序

若是在面試中有面試官要求你寫一個O(n)時間複雜度的排序算法，你千萬不要馬上說：這不可能！雖然前面基於比較的排序的下限是O(nlogn)。可是確實也有線性時間複雜度的排序，只不過有前提條件，就是待排序的數要知足必定的範圍的整數，並且計數排序須要比較多的輔助空間。其基本思想是，用待排序的數做爲計數數組的下標，統計每一個數字的個數。而後依次輸出便可獲得有序序列。

實現代碼：

/**
 *@Description:<p>計數排序算法實現</p>
 *@author 王旭
 *@time 2016-3-4 下午4:52:02
 */
public class CountSort {

    public static void countSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;

        int max = max(arr);

        int[] count = new int[max+1];
        Arrays.fill(count, 0);

        for(int i=0; i<arr.length; i++) {
            count[arr[i]] ++;
        }

        int k = 0;
        for(int i=0; i<=max; i++) {
            for(int j=0; j<count[i]; j++) {
                arr[k++] = i;
            }
        }

    }

    public static int max(int[] arr) {
        int max = Integer.MIN_VALUE;
        for(int ele : arr) {
            if(ele > max)
                max = ele;
        }

        return max;
    }

}
複製代碼

桶排序

桶排序算是計數排序的一種改進和推廣，可是網上有許多資料把計數排序和桶排序混爲一談。其實桶排序要比計數排序複雜許多。

對桶排序的分析和解釋借鑑這位兄弟的文章（有改動）：hxraid.iteye.com/blog/647759

桶排序的基本思想：

假設有一組長度爲N的待排關鍵字序列K[1....n]。首先將這個序列劃分紅M個的子區間(桶) 。而後基於某種映射函數 ，將待排序列的關鍵字k映射到第i個桶中(即桶數組B的下標 i) ，那麼該關鍵字k就做爲B[i]中的元素(每一個桶B[i]都是一組大小爲N/M的序列)。接着對每一個桶B[i]中的全部元素進行比較排序(可使用快排)。而後依次枚舉輸出B[0]….B[M]中的所有內容便是一個有序序列。bindex=f(key) 其中，bindex 爲桶數組B的下標(即第bindex個桶), k爲待排序列的關鍵字。桶排序之因此可以高效，其關鍵在於這個映射函數，它必須作到：若是關鍵字k1<k2，那麼f(k1)<=f(k2)。也就是說B(i)中的最小數據都要大於B(i-1)中最大數據。很顯然，映射函數的肯定與數據自己的特色有很大的關係。

舉個栗子：

img

假如待排序列K= {4九、 38 、 3五、 97 、 7六、 73 、 2七、 49 }。這些數據所有在1—100之間。所以咱們定製10個桶，而後肯定映射函數f(k)=k/10。則第一個關鍵字49將定位到第4個桶中(49/10=4)。依次將全部關鍵字所有堆入桶中，並在每一個非空的桶中進行快速排序後獲得如圖所示。只要順序輸出每一個B[i]中的數據就能夠獲得有序序列了。

桶排序分析：

桶排序利用函數的映射關係，減小了幾乎全部的比較工做。實際上，桶排序的f(k)值的計算，其做用就至關於快排中劃分，希爾排序中的子序列，歸併排序中的子問題，已經把大量數據分割成了基本有序的數據塊(桶)。而後只須要對桶中的少許數據作先進的比較排序便可。

對N個關鍵字進行桶排序的時間複雜度分爲兩個部分：

(1) 循環計算每一個關鍵字的桶映射函數，這個時間複雜度是O(N)。

(2) 利用先進的比較排序算法對每一個桶內的全部數據進行排序，其時間複雜度爲 ∑ O(Ni*logNi) 。其中Ni 爲第i個桶的數據量。

很顯然，第(2)部分是桶排序性能好壞的決定因素。儘可能減小桶內數據的數量是提升效率的惟一辦法(由於基於比較排序的最好平均時間複雜度只能達到O(N*logN)了)。所以，咱們須要儘可能作到下面兩點：

(1) 映射函數f(k)可以將N個數據平均的分配到M個桶中，這樣每一個桶就有[N/M]個數據量。

(2) 儘可能的增大桶的數量。極限狀況下每一個桶只能獲得一個數據，這樣就徹底避開了桶內數據的「比較」排序操做。固然，作到這一點很不容易，數據量巨大的狀況下，f(k)函數會使得桶集合的數量巨大，空間浪費嚴重。這就是一個時間代價和空間代價的權衡問題了。

對於N個待排數據，M個桶，平均每一個桶[N/M]個數據的桶排序平均時間複雜度爲：

O(N)+O(M*(N/M)log(N/M))=O(N+N(logN-logM))=O(N+NlogN-NlogM)

當N=M時，即極限狀況下每一個桶只有一個數據時。桶排序的最好效率可以達到O(N)。

總結： 桶排序的平均時間複雜度爲線性的O(N+C)，其中C=N*(logN-logM)。若是相對於一樣的N，桶數量M越大，其效率越高，最好的時間複雜度達到O(N)。 固然桶排序的空間複雜度 爲O(N+M)，若是輸入數據很是龐大，而桶的數量也很是多，則空間代價無疑是昂貴的。此外，桶排序是穩定的。

實現代碼：

/**
 *@Description:<p>桶排序算法實現</p>
 *@author 王旭
 *@time 2016-3-4 下午7:39:31
 */
public class BucketSort {

    public static void bucketSort(int[] arr) {
        if(arr == null && arr.length == 0)
            return ;

        int bucketNums = 10; //這裏默認爲10，規定待排數[0,100)
        List<List<Integer>> buckets = new ArrayList<List<Integer>>(); //桶的索引

        for(int i=0; i<10; i++) {
            buckets.add(new LinkedList<Integer>()); //用鏈表比較合適
        }

        //劃分桶
        for(int i=0; i<arr.length; i++) {
            buckets.get(f(arr[i])).add(arr[i]);
        }

        //對每一個桶進行排序
        for(int i=0; i<buckets.size(); i++) {
            if(!buckets.get(i).isEmpty()) {
                Collections.sort(buckets.get(i)); //對每一個桶進行快排
            }
        }

        //還原排好序的數組
        int k = 0;
        for(List<Integer> bucket : buckets) {
            for(int ele : bucket) {
                arr[k++] = ele;
            }
        }
    }

    /**
     * 映射函數
     * @param x
     * @return
     */
    public static int f(int x) {
        return x / 10;
    }

}
複製代碼

基數排序

基數排序又是一種和前面排序方式不一樣的排序方式，基數排序不須要進行記錄關鍵字之間的比較。基數排序是一種藉助多關鍵字排序思想對單邏輯關鍵字進行排序的方法。所謂的多關鍵字排序就是有多個優先級不一樣的關鍵字。好比說成績的排序，若是兩我的總分相同，則語文高的排在前面，語文成績也相同則數學高的排在前面。。。若是對數字進行排序，那麼個位、十位、百位就是不一樣優先級的關鍵字，若是要進行升序排序，那麼個位、十位、百位優先級一次增長。基數排序是經過屢次的收分配和收集來實現的，關鍵字優先級低的先進行分配和收集。

舉個栗子：

img

img

實現代碼：

/**
 *@Description:<p>基數排序算法實現</p>
 *@author 王旭
 *@time 2016-3-4 下午8:29:52
 */
public class RadixSort {

    public static void radixSort(int[] arr) {
        if(arr == null && arr.length == 0)
            return ;

        int maxBit = getMaxBit(arr);

        for(int i=1; i<=maxBit; i++) {

            List<List<Integer>> buf = distribute(arr, i); //分配
            collecte(arr, buf); //收集
        }

    }

    /**
     * 分配
     * @param arr 待分配數組
     * @param iBit 要分配第幾位
     * @return
     */
    public static List<List<Integer>> distribute(int[] arr, int iBit) {
        List<List<Integer>> buf = new ArrayList<List<Integer>>();
        for(int j=0; j<10; j++) {
            buf.add(new LinkedList<Integer>());
        }
        for(int i=0; i<arr.length; i++) {
            buf.get(getNBit(arr[i], iBit)).add(arr[i]);
        }
        return buf;
    }

    /**
     * 收集
     * @param arr 把分配的數據收集到arr中
     * @param buf 
     */
    public static void collecte(int[] arr, List<List<Integer>> buf) {
        int k = 0;
        for(List<Integer> bucket : buf) {
            for(int ele : bucket) {
                arr[k++] = ele;
            }
        }

    }

    /**
     * 獲取最大位數
     * @param x
     * @return
     */
    public static int getMaxBit(int[] arr) {
        int max = Integer.MIN_VALUE;
        for(int ele : arr) {
            int len = (ele+"").length();
            if(len > max)
                max = len;
        }
        return max;
    }

    /**
     * 獲取x的第n位，若是沒有則爲0.
     * @param x
     * @param n
     * @return
     */
    public static int getNBit(int x, int n) {

        String sx = x + "";
        if(sx.length() < n)
            return 0;
        else
            return sx.charAt(sx.length()-n) - '0';
    }

}
複製代碼

總結

在前面的介紹和分析中咱們提到了冒泡排序、選擇排序、插入排序三種簡單的排序及其變種快速排序、堆排序、希爾排序三種比較高效的排序。後面咱們又分析了基於分治遞歸思想的歸併排序還有計數排序、桶排序、基數排序三種線性排序。咱們能夠知道排序算法要麼簡單有效，要麼是利用簡單排序的特色加以改進，要麼是以空間換取時間在特定狀況下的高效排序。可是這些排序方法都不是固定不變的，須要結合具體的需求和場景來選擇甚至組合使用。才能達到高效穩定的目的。沒有最好的排序，只有最適合的排序。

下面就總結一下排序算法的各自的使用場景和適用場合。

img

\1. 從平均時間來看，快速排序是效率最高的，但快速排序在最壞狀況下的時間性能不如堆排序和歸併排序。然後者相比較的結果是，在n較大時歸併排序使用時間較少，但使用輔助空間較多。

\2. 上面說的簡單排序包括除希爾排序以外的全部冒泡排序、插入排序、簡單選擇排序。其中直接插入排序最簡單，但序列基本有序或者n較小時，直接插入排序是好的方法，所以常將它和其餘的排序方法，如快速排序、歸併排序等結合在一塊兒使用。

\3. 基數排序的時間複雜度也能夠寫成O(d*n)。所以它最使用於n值很大而關鍵字較小的的序列。若關鍵字也很大，而序列中大多數記錄的最高關鍵字均不一樣，則亦可先按最高關鍵字不一樣，將序列分紅若干小的子序列，然後進行直接插入排序。

\4. 從方法的穩定性來比較，基數排序是穩定的內排方法，全部時間複雜度爲O(n^2)的簡單排序也是穩定的。可是快速排序、堆排序、希爾排序等時間性能較好的排序方法都是不穩定的。穩定性須要根據具體需求選擇。

\5. 上面的算法實現大多數是使用線性存儲結構，像插入排序這種算法用鏈表實現更好，省去了移動元素的時間。具體的存儲結構在具體的實現版本中也是不一樣的。

附：基於比較排序算法時間下限爲O(nlogn)的證實：

基於比較排序下限的證實是經過決策樹證實的，決策樹的高度Ω（nlgn），這樣就得出了比較排序的下限。

img

首先要引入決策樹。 首先決策樹是一顆二叉樹，每一個節點表示元素之間一組可能的排序，它予以京進行的比較相一致，比較的結果是樹的邊。 先來講明一些二叉樹的性質，令T是深度爲d的二叉樹，則T最多有2^片樹葉。 具備L片樹葉的二叉樹的深度至少是logL。 因此，對n個元素排序的決策樹必然有n!片樹葉（由於n個數有n!種不一樣的大小關係），因此決策樹的深度至少是log(n!)，即至少須要log(n!)次比較。 而 log(n!)=logn+log(n-1)+log(n-2)+…+log2+log1 >=logn+log(n-1)+log(n-2)+…+log(n/2) >=(n/2)log(n/2) >=(n/2)logn-n/2 =O(nlogn) 因此只用到比較的排序算法最低時間複雜度是O(nlogn)。

參考資料：

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程