面試必備：八種排序算法原理及Java實現

1. 概述

排序算法分爲內部排序和外部排序，內部排序把數據記錄放在內存中進行排序，而外部排序因排序的數據量大，內存不能一次容納所有的排序記錄，因此在排序過程當中須要訪問外存。

常常說起的八大排序算法指的就是內部排序的八種算法，分別是冒泡排序、快速排序、直接插入排序、希爾排序、簡單選擇排序、堆排序、歸併排序和基數排序，若是按原理劃分，冒泡排序和快速排序都屬於交換排序，直接插入排序和希爾排序屬於插入排序，而簡單選擇排序和堆排序屬於選擇排序，如上圖所示。

2. 冒泡排序

2.1 基本思想

冒泡排序（Bubble Sort）是一種簡單的排序算法。它重複訪問要排序的數列，一次比較兩個元素，若是他們的順序錯誤就把他們交換過來。訪問數列的工做是重複地進行直到沒有再須要交換的數據，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端，像水中的氣泡從水底浮到水面。

2.2 算法描述

冒泡排序算法的算法過程以下：

①. 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。

②. 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。這步作完後，最後的元素會是最大的數。

③. 針對全部的元素重複以上的步驟，除了最後一個。

④. 持續每次對愈來愈少的元素重複上面的步驟①~③，直到沒有任何一對數字須要比較。

2.3 代碼實現

package com.fufu.algorithm.sort;

import java.util.Arrays;

/** * 冒泡排序 * Created by zhoujunfu on 2018/8/2. */
public class BubbleSort {
    public static void sort(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }

        int length = array.length;
        //外層：須要length-1次循環比較
        for (int i = 0; i < length - 1; i++) {
            //內層：每次循環須要兩兩比較的次數，每次比較後，都會將當前最大的數放到最後位置，因此每次比較次數遞減一次
            for (int j = 0; j < length - 1 - i; j++) {
                if (array[j] > array[j+1]) {
                    //交換數組array的j和j+1位置的數據
                    swap(array, j, j+1);
                }
            }
        }
    }

    /** * 交換數組array的i和j位置的數據 * @param array 數組 * @param i 下標i * @param j 下標j */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

複製代碼

2.4 算法效率

冒泡排序是穩定的排序算法，最容易實現的排序, 最壞的狀況是每次都須要交換, 共需遍歷並交換將近n²/2次, 時間複雜度爲O(n²). 最佳的狀況是內循環遍歷一次後發現排序是對的, 所以退出循環, 時間複雜度爲O(n). 平均來說, 時間複雜度爲O(n²). 因爲冒泡排序中只有緩存的temp變量須要內存空間, 所以空間複雜度爲常量O(1)。

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(n2)	O(n)	O(n2)	O(1)

2.5 交換數字的三種方法

咱們從冒泡排序的代碼中看到了交換兩個數字的方法 swap(int[] array, int i, int j)，這裏使用了臨時變量，而交換數字主要有三種方法，臨時變量法、算術法、位運算法、面試中常常會問到，這裏簡單說一下，代碼以下：

package com.fufu.algorithm.sort;

import java.util.Arrays;

/** * Created by zhoujunfu on 2018/9/10. */
public class SwapDemo {

    public static void main(String[] args) {
        // 臨時變量法
        int[] array = new int[]{10, 20};
        System.out.println(Arrays.toString(array));
        swapByTemp(array, 0, 1);
        System.out.println(Arrays.toString(array));
        
        // 算術法
        array = new int[]{10, 20};
        swapByArithmetic(array, 0, 1);
        System.out.println(Arrays.toString(array));
        
        // 位運算法
        array = new int[]{10, 20};
        swapByBitOperation(array, 0, 1);
        System.out.println(Arrays.toString(array));
    }

    /** * 經過臨時變量交換數組array的i和j位置的數據 * @param array 數組 * @param i 下標i * @param j 下標j */
    public static void swapByTemp(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    /** * 經過算術法交換數組array的i和j位置的數據（有可能溢出） * @param array 數組 * @param i 下標i * @param j 下標j */
    public static void swapByArithmetic(int[] array, int i, int j) {
        array[i] = array[i] + array[j];
        array[j] = array[i] - array[j];
        array[i] = array[i] - array[j];
    }


    /** * 經過位運算法交換數組array的i和j位置的數據 * @param array 數組 * @param i 下標i * @param j 下標j */
    public static void swapByBitOperation(int[] array, int i, int j) {
        array[i] = array[i]^array[j];
        array[j] = array[i]^array[j]; //array[i]^array[j]^array[j]=array[i]
        array[i] = array[i]^array[j]; //array[i]^array[j]^array[i]=array[j]
    }
}

複製代碼

3. 快速排序

3.1 基本思想

快速排序（Quicksort）是對冒泡排序的一種改進，借用了分治的思想，由C. A. R. Hoare在1962年提出。它的基本思想是：經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據都比另一部分的全部數據都要小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程能夠遞歸進行，以此達到整個數據變成有序序列。

3.2 算法描述

快速排序使用分治策略來把一個序列（list）分爲兩個子序列（sub-lists）。步驟爲：

①. 從數列中挑出一個元素，稱爲」基準」（pivot）。

②. 從新排序數列，全部比基準值小的元素擺放在基準前面，全部比基準值大的元素擺在基準後面（相同的數能夠到任一邊）。在這個分區結束以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做。

③. 遞歸地（recursively）把小於基準值元素的子數列和大於基準值元素的子數列排序。

遞歸到最底部時，數列的大小是零或一，也就是已經排序好了。這個算法必定會結束，由於在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

3.3 代碼實現

①. 挖坑法 用僞代碼描述以下：

（1）low = L; high = R; 將基準數挖出造成第一個坑a[low]。

（2）high--，由後向前找比它小的數，找到後挖出此數填前一個坑a[low]中。

（3）low++，由前向後找比它大的數，找到後也挖出此數填到前一個坑a[high]中。

（4）再重複執行②，③二步，直到low==high，將基準數填入a[low]中。

舉例說明： 一個無序數組：[4, 3, 7, 5, 10, 9, 1, 6, 8, 2]

（1）隨便先挖個坑，就在第一個元素（基準元素）挖坑，挖出來的「蘿蔔」（第一個元素4）在「籃子」（臨時變量）裏備用。 挖完以後的數組是這樣：[ 坑, 3, 7, 5, 10, 9, 1, 6, 8,2]

（2）挖右坑填左坑：從右邊開始，找個比「蘿蔔」（元素4）小的元素，挖出來，填到前一個坑裏面。 填坑以後：[ 2, 3, 7, 5, 10, 9, 1, 6, 8,坑]

（3）挖左坑填右坑：從左邊開始，找個比「蘿蔔」（元素4）大的元素，挖出來，填到右邊的坑裏面。 填坑以後：[ 2, 3,坑, 5, 10, 9, 1, 6, 8, 7]

（4）挖右坑填左坑：從右邊開始，找個比「蘿蔔」（元素4）小的元素，挖出來，填到前一個坑裏面。 填坑以後：[ 2, 3, 1, 5, 10, 9,坑, 6, 8, 7]

（5）挖左坑填右坑：從左邊開始，找個比「蘿蔔」（元素4）大的元素，挖出來，填到右邊的坑裏面。 填坑以後：[ 2, 3, 1,坑, 10, 9, 5, 6, 8, 7]

（6）挖右坑填左坑：從右邊開始，找個比「蘿蔔」（元素4）小的元素，挖出來，填到前一個坑裏面，這一次找坑的過程當中，找到了上一次挖的坑了，說明能夠停了，用籃子裏的的蘿蔔，把這個坑填了就好了，而且返回這個坑的位置，做爲分而治之的中軸線。 填坑以後：[ 2, 3, 1, 4, 10, 9, 5, 6, 8, 7]

上面的步驟中，第2，4, 6其實都是同樣的操做，3和5的操做也是同樣的，代碼以下：

/**
     *  快速排序（挖坑法遞歸）
     * @param arr   待排序數組
     * @param low   左邊界
     * @param high  右邊界
     */
    public static void sort(int arr[], int low, int high) {
        if (arr == null || arr.length <= 0) {
            return;
        }
        if (low >= high) {
            return;
        }

        int left = low;
        int right = high;
        int temp = arr[left]; //挖坑1：保存基準的值

        while (left < right) {
            while (left < right && arr[right] >= temp) {
                right--;
            }
            arr[left] = arr[right]; //坑2：從後向前找到比基準小的元素，插入到基準位置坑1中
            while (left < right && arr[left] <= temp) {
                left ++;
            }
            arr[right] = arr[left]; //坑3：從前日後找到比基準大的元素，放到剛纔挖的坑2中
        }
        arr[left] = temp; //基準值填補到坑3中，準備分治遞歸快排
        System.out.println("Sorting: " + Arrays.toString(arr));
        sort(arr, low, left-1);
        sort(arr, left + 1, high);
    }
複製代碼

②. 左右指針法

用僞代碼描述以下：

（1）low = L; high = R; 選取a[low]做爲關鍵字記錄爲key。

（2）high--，由後向前找比它小的數

（3）low++，由前向後找比它大的數

（4）交換第（2）、（3）步找到的數

（5）重複（2）、（3），一直日後找，直到left和right相遇，這時將key和a[low]交換位置。

代碼以下：

/** * 快速排序 * Created by zhoujunfu on 2018/8/6. */
public class QuickSort {
    /** * 快速排序（左右指針法） * @param arr 待排序數組 * @param low 左邊界 * @param high 右邊界 */
    public static void sort2(int arr[], int low, int high) {
        if (arr == null || arr.length <= 0) {
            return;
        }
        if (low >= high) {
            return;
        }

        int left = low;
        int right = high;

        int key = arr[left];

        while (left < right) {
            while (left < right && arr[right] >= key) {
                right--;
            }
            while (left < right && arr[left] <= key) {
                left++;
            }
            if (left < right) {
                swap(arr, left, right);
            }
        }
        swap(arr, low, left);
        System.out.println("Sorting: " + Arrays.toString(arr));
        sort2(arr, low, left - 1);
        sort2(arr, left + 1, high);
    }

    public static void swap(int arr[], int low, int high) {
        int tmp = arr[low];
        arr[low] = arr[high];
        arr[high] = tmp;
    }
}
複製代碼

3.4 算法效率

快速排序並不穩定，快速排序每次交換的元素都有可能不是相鄰的, 所以它有可能打破原來值爲相同的元素之間的順序。

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(nlogn)	O(nlogn)	O(n2)	O(1)

4. 直接插入排序

4.1 基本思想

直接插入排序的基本思想是：將數組中的全部元素依次跟前面已經排好的元素相比較，若是選擇的元素比已排序的元素小，則交換，直到所有元素都比較過爲止。

4.2 算法描述

通常來講，插入排序都採用in-place在數組上實現。具體算法描述以下：

①. 從第一個元素開始，該元素能夠認爲已經被排序

②. 取出下一個元素，在已經排序的元素序列中從後向前掃描

③. 若是該元素（已排序）大於新元素，將該元素移到下一位置

④. 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置

⑤. 將新元素插入到該位置後

⑥. 重複步驟②~⑤

4.3 代碼實現

提供兩種寫法，一種是移位法，一種是交換法。移位法是徹底按照以上算法描述實，再插入過程當中將有序序列中比待插入數字大的數據向後移動，因爲移動時會覆蓋待插入數據，因此須要額外的臨時變量保存待插入數據，代碼實現以下：

①. 移位法：

public static void sort(int[] a) {
        if (a == null || a.length == 0) {
            return;
        }

        for (int i = 1; i < a.length; i++) {
            int j = i - 1;
            int temp = a[i]; // 先取出待插入數據保存，由於向後移位過程當中會把覆蓋掉待插入數
            while (j >= 0 && a[j] > temp) { // 若是待是比待插入數據大，就後移
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = temp; // 找到比待插入數據小的位置，將待插入數據插入
        }
    }
複製代碼

而交換法不需求額外的保存待插入數據，經過不停的向前交換帶插入數據，相似冒泡法，直到找到比它小的值，也就是待插入數據找到了本身的位置。
②. 交換法：

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

        for (int i = 1; i < arr.length; i ++) {
            int j = i - 1;
            while (j >= 0 && arr[j] > arr[i]) {
                arr[j + 1] = arr[j] + arr[j+1];      //只要大就交換操做
                arr[j] = arr[j + 1] - arr[j];
                arr[j + 1] = arr[j + 1] - arr[j];
                System.out.println("Sorting: " + Arrays.toString(arr));
            }
        }
    }
複製代碼

4.4 算法效率

直接插入排序不是穩定的排序算法。

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(n2)	O(n)	O(n2)	O(1)

5.希爾排序

希爾排序，也稱遞減增量排序算法，1959年Shell發明。是插入排序的一種高速而穩定的改進版本。

希爾排序是先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄「基本有序」時，再對全體記錄進行依次直接插入排序。

5.1 基本思想

將待排序數組按照步長gap進行分組，而後將每組的元素利用直接插入排序的方法進行排序；每次再將gap折半減少，循環上述操做；當gap=1時，利用直接插入，完成排序。

能夠看到步長的選擇是希爾排序的重要部分。只要最終步長爲1任何步長序列均可以工做。通常來講最簡單的步長取值是初次取數組長度的一半爲增量，以後每次再減半，直到增量爲1。更好的步長序列取值能夠參考維基百科。

5.2 算法描述

①. 選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；（通常初次取數組半長，以後每次再減半，直到增量爲1）

②. 按增量序列個數k，對序列進行k 趟排序；

③. 每趟排序，根據對應的增量ti，將待排序列分割成若干長度爲m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲1 時，整個序列做爲一個表來處理，表長度即爲整個序列的長度。

在上面這幅圖中： 初始時，有一個大小爲 10 的無序序列。

在第一趟排序中，咱們不妨設 gap1 = N / 2 = 5，即相隔距離爲 5 的元素組成一組，能夠分爲 5 組。

接下來，按照直接插入排序的方法對每一個組進行排序。

在第二趟排序中，咱們把上次的 gap 縮小一半，即 gap2 = gap1 / 2 = 2 (取整數)。這樣每相隔距離爲 2 的元素組成一組，能夠分爲 2 組。

按照直接插入排序的方法對每一個組進行排序。

在第三趟排序中，再次把 gap 縮小一半，即gap3 = gap2 / 2 = 1。 這樣相隔距離爲 1 的元素組成一組，即只有一組。 按照直接插入排序的方法對每一個組進行排序。此時，排序已經結束。

須要注意一下的是，圖中有兩個相等數值的元素 5 和 5 。咱們能夠清楚的看到，在排序過程當中，兩個元素位置交換了。 因此，希爾排序是不穩定的算法。

5.3 代碼實現

public class ShellSort {

    public static void sort(int[] arr) {
        int gap = arr.length / 2;
        for (;gap > 0; gap = gap/2) {
            for (int j = 0; (j + gap) < arr.length; j++) { //不斷縮小gap，直到1爲止
                for (int k = 0; (k + gap) < arr.length; k+=gap) { //使用當前gap進行組內插入排序
                    if (arr[k] > arr[k+gap]) { //交換操做
                        arr[k] = arr[k] + arr[k+gap];
                        arr[k+gap] = arr[k] - arr[k+gap];
                        arr[k] = arr[k] - arr[k+gap];
                        System.out.println(" Sorting: " + Arrays.toString(arr));
                    }
                }
            }
        }
    }
}
複製代碼

5.4 算法效率

不穩定排序算法，希爾排序第一個突破O(n²)的排序算法；是簡單插入排序的改進版；它與插入排序的不一樣之處在於，它會優先比較距離較遠的元素，直接插入排序是穩定的；而希爾排序是不穩定的，希爾排序的時間複雜度和步長的選擇有關，經常使用的是Shell增量排序，也就是N/2的序列，Shell增量序列不是最好的增量序列，其餘還有Hibbard增量序列、Sedgewick 增量序列等，具體能夠參考，希爾排序增量序列簡介。

6.選擇排序

6.1 基本思想

在未排序序列中找到最小（大）元素，存放到未排序序列的起始位置。在全部的徹底依靠交換去移動元素的排序方法中，選擇排序屬於很是好的一種。

6.2 算法描述

①. 從待排序序列中，找到關鍵字最小的元素；

②. 若是最小元素不是待排序序列的第一個元素，將其和第一個元素互換；

③. 從餘下的 N - 1 個元素中，找出關鍵字最小的元素，重複①、②步，直到排序結束。

6.3 代碼實現

public class SelectSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            for (int j = i+1; j < arr.length; j ++) { //選出以後待排序中值最小的位置
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            if (min != i) {
                arr[min] = arr[i] + arr[min];
                arr[i] = arr[min] - arr[i];
                arr[min] = arr[min] - arr[i];
            }
        }
    }
複製代碼

6.4 算法效率

不穩定排序算法，選擇排序的簡單和直觀名副其實，這也造就了它出了名的慢性子，不管是哪一種狀況，哪怕原數組已排序完成，它也將花費將近n²/2次遍從來確認一遍。 惟一值得高興的是，它並不耗費額外的內存空間。

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(n2)	O(n2)	O(n2)	O(1)

7.歸併排序

歸併排序是創建在歸併操做上的一種有效的排序算法，1945年由約翰·馮·諾伊曼首次提出。該算法是採用分治法（Divide and Conquer）的一個很是典型的應用，且各層分治遞歸能夠同時進行。

7.1 基本思想

歸併排序算法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分爲若干個子序列，每一個子序列是有序的。而後再把有序子序列合併爲總體有序序列。

7.2 算法描述

採用遞歸法： ①. 將序列每相鄰兩個數字進行歸併操做，造成 floor(n/2)個序列，排序後每一個序列包含兩個元素；

②. 將上述序列再次歸併，造成 floor(n/4)個序列，每一個序列包含四個元素；

③. 重複步驟②，直到全部元素排序完畢

7.3 代碼實現

package com.fufu.algorithm.sort;

import java.util.Arrays;

/**
 * Created by zhoujunfu on 2018/8/10.
 */
public class MergeSort {

    public static int[] sort(int [] a) {
        if (a.length <= 1) {
            return a;
        }
        int num = a.length >> 1;
        int[] left = Arrays.copyOfRange(a, 0, num);
        int[] right = Arrays.copyOfRange(a, num, a.length);
        return mergeTwoArray(sort(left), sort(right));
    }

    public static int[] mergeTwoArray(int[] a, int[] b) {
        int i = 0, j = 0, k = 0;
        int[] result = new int[a.length + b.length]; // 申請額外空間保存歸併以後數據

        while (i < a.length && j < b.length) { //選取兩個序列中的較小值放入新數組
            if (a[i] <= b[j]) {
                result[k++] = a[i++];
            } else {
                result[k++] = b[j++];
            }
        }

        while (i < a.length) { //序列a中多餘的元素移入新數組
            result[k++] = a[i++];
        }
        while (j < b.length) {//序列b中多餘的元素移入新數組
            result[k++] = b[j++];
        }
        return result;
    }

    public static void main(String[] args) {
        int[] b = {3, 1, 5, 4};
        System.out.println(Arrays.toString(sort(b)));
    }
}
複製代碼

7.4 算法效率

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(nlogn)	O(nlogn)	O(nlogn)	O(n)

穩定排序算法，從效率上看，歸併排序可算是排序算法中的」佼佼者」. 假設數組長度爲n，那麼拆分數組共需logn, 又每步都是一個普通的合併子數組的過程，時間複雜度爲O(n)， 故其綜合時間複雜度爲O(nlogn)。另外一方面， 歸併排序屢次遞歸過程當中拆分的子數組須要保存在內存空間， 其空間複雜度爲O(n)。 和選擇排序同樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，由於始終都是O(nlogn）的時間複雜度。代價是須要額外的內存空間。

8.基數排序

基數排序（Radix sort）是一種非比較型整數排序算法，其原理是將整數按位數切割成不一樣的數字，而後按每一個位數分別比較。因爲整數也能夠表達字符串（好比名字或日期）和特定格式的浮點數，因此基數排序也不是隻能使用於整數。

8.1 基本思想

將全部待比較數值（正整數）統一爲一樣的數位長度，數位較短的數前面補零。而後，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成之後，數列就變成一個有序序列。

基數排序按照優先從高位或低位來排序有兩種實現方案：

MSD（Most significant digital） 從最左側高位開始進行排序。先按k1排序分組, 同一組中記錄, 關鍵碼k1相等, 再對各組按k2排序分紅子組, 以後, 對後面的關鍵碼繼續這樣的排序分組, 直到按最次位關鍵碼kd對各子組排序後. 再將各組鏈接起來, 便獲得一個有序序列。MSD方式適用於位數多的序列。

LSD（Least significant digital） 從最右側低位開始進行排序。先從kd開始排序，再對kd-1進行排序，依次重複，直到對k1排序後便獲得一個有序序列。LSD方式適用於位數少的序列。

下圖是LSD基數排序的示意圖：

8.2 算法描述

以LSD爲例，從最低位開始，具體算法描述以下：

①. 取得數組中的最大數，並取得位數； ②. arr爲原始數組，從最低位開始取每一個位組成radix數組； ③. 對radix進行計數排序（利用計數排序適用於小範圍數的特色）；

8.3 代碼實現

基數排序：經過序列中各個元素的值，對排序的N個元素進行若干趟的「分配」與「收集」來實現排序。

分配：咱們將L[i]中的元素取出，首先肯定其個位上的數字，根據該數字分配到與之序號相同的桶中

收集：當序列中全部的元素都分配到對應的桶中，再按照順序依次將桶中的元素收集造成新的一個待排序列L[]。對新造成的序列L[]重複執行分配和收集元素中的十位、百位…直到分配完該序列中的最高位，則排序結束

package com.fufu.algorithm.sort;

import java.util.Arrays;

/**
 * Created by zhoujunfu on 2018/9/11.
 * 基數排序LSD
 */
public class RadixSort {

    public static void main(String[] args) {
        int[] array = {10, 20, 5, 4, 100};
        sort(array);

    }

    public static void sort(int[] a) {

        if (a == null || a.length < 0) {
            return;
        }

        int max = a[0];
        for (int i = 0; i <a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        System.out.println("max, " + max);

        int maxDigit = 0;
        while (max != 0) {
            max = max / 10;
            maxDigit++;
        }
        System.out.println("maxDigit, " + maxDigit);

        int[][] buckets = new int[10][a.length];
        int base = 10;

        //從低位到高位，對每一位遍歷，將全部元素分配到桶中
        for (int i = 0; i < maxDigit; i++) {
            int[] bucketLen = new int[10];  //存儲各個桶中存儲元素的數量

            //收集：將不一樣桶裏數據挨個撈出來,爲下一輪高位排序作準備,因爲靠近桶底的元素排名靠前,所以從桶底先撈
            for (int j = 0; j < a.length; j++) {
                int whichBucket = (a[j] % base) / (base / 10);
                buckets[whichBucket][bucketLen[whichBucket]] = a[j];
                bucketLen[whichBucket]++;
            }

            int k = 0;
            //收集：將不一樣桶裏數據挨個撈出來,爲下一輪高位排序作準備,因爲靠近桶底的元素排名靠前,所以從桶底先撈
            for (int l = 0; l < buckets.length; l++) {
                for (int m =0; m < bucketLen[l]; m++) {
                    a[k++] = buckets[l][m];
                }
            }
            System.out.println("Sorting: " + Arrays.toString(a));
            base *= 10;
        }
    }
}
複製代碼

8.4 算法效率

基數排序不改變相同元素之間的相對順序，所以它是穩定的排序算法，如下是基數排序算法複雜度：

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(d*(n+r))	O(d*(n+r))	O(d*(n+r))	O(n+r)

其中，d 爲位數，r 爲基數，n 爲原數組個數。在基數排序中，由於沒有比較操做，因此在複雜上，最好的狀況與最壞的狀況在時間上是一致的，均爲 O(d*(n + r))。

基數排序更適合用於對時間, 字符串等這些總體權值未知的數據進行排序，適用於。

(1)數據範圍較小，建議在小於1000

(2)每一個數值都要大於等於0

基數排序 vs 計數排序 vs 桶排序

這三種排序算法都利用了桶的概念，但對桶的使用方法上有明顯差別：

基數排序：根據鍵值的每位數字來分配桶
計數排序：每一個桶只存儲單一鍵值
桶排序：每一個桶存儲必定範圍的數值

計數排序和桶排序在這篇文章裏具體就不寫了，有須要的能夠自行百度。

9.堆排序

看堆排序以前先介紹一下面幾個概念：

徹底二叉樹： 若設二叉樹的深度爲h，除第 h 層外，其它各層 (1～h-1) 的結點數都達到最大個數，第 h 層全部的結點都連續集中在最左邊，這就是徹底二叉樹，很好理解以下圖所示。

堆： 堆是具備如下性質的徹底二叉樹，每一個結點的值都大於或等於其左右孩子結點的值，稱爲大頂堆；或者每一個結點的值都小於或等於其左右孩子結點的值，稱爲小頂堆。以下圖：

同時，咱們對堆中的結點按層進行編號，將這種邏輯結構映射到數組中就是下面這個樣子：

該數組從邏輯上講就是一個堆結構，咱們用簡單的公式來描述一下堆的定義就是：

大頂堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小頂堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

ok，瞭解了這些定義。接下來，咱們來看看堆排序的基本思想及基本步驟：

9.1 基本思想

堆排序的基本思想是：將待排序序列構形成一個大頂堆，此時，整個序列的最大值就是堆頂的根節點。將其與末尾元素進行交換，此時末尾就爲最大值。而後將剩餘n-1個元素從新構形成一個堆，這樣會獲得n個元素的次小值。如此反覆執行，便能獲得一個有序序列了。

9.2 算法描述

步驟一 構造初始堆。將給定無序序列構形成一個大頂堆（通常升序採用大頂堆，降序採用小頂堆)。

1.假設給定無序序列結構以下

2.此時咱們從最後一個非葉子結點開始（葉結點天然不用調整，第一個非葉子結點 arr.length/2-1=5/2-1=1，也就是下面的6結點），從左至右，從下至上進行調整。

3.找到第二個非葉節點4，因爲[4,9,8]中9元素最大，4和9交換。

這時，交換致使了子根[4,5,6]結構混亂，繼續調整，[4,5,6]中6最大，交換4和6。

此時，咱們就將一個無需序列構形成了一個大頂堆。

步驟二 將堆頂元素與末尾元素進行交換，使末尾元素最大。而後繼續調整堆，再將堆頂元素與末尾元素交換，獲得第二大元素。如此反覆進行交換、重建、交換。

b.從新調整結構，使其繼續知足堆定義

c.再將堆頂元素8與末尾元素5進行交換，獲得第二大元素8.

後續過程，繼續進行調整，交換，如此反覆進行，最終使得整個序列有序

再簡單總結下堆排序的基本思路：

  a.將無需序列構建成一個堆，根據升序降序需求選擇大頂堆或小頂堆;

  b.將堆頂元素與末尾元素交換，將最大元素"沉"到數組末端;

  c.從新調整結構，使其知足堆定義，而後繼續交換堆頂元素與當前末尾元素，反覆執行調整+交換步驟，直到整個序列有序。      

9.3 算法實現

package com.fufu.algorithm.sort;

import java.util.Arrays;

/**
 * Created by zhoujunfu on 2018/9/26.
 */
public class HeapSort {

    public static void main(String []args){
        int []arr = {4,6,8,5,9};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        //1.構建大頂堆
        for(int i=arr.length/2-1;i>=0;i--){
            //從第一個非葉子結點從下至上，從右至左調整結構
            adjustHeap(arr,i,arr.length);
        }
        //2.調整堆結構+交換堆頂元素與末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//將堆頂元素與末尾元素進行交換
            adjustHeap(arr,0,j);//從新對堆進行調整
        }

    }

    /**
     * 調整大頂堆（僅是調整過程，創建在大頂堆已構建的基礎上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出當前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//從i結點的左子結點開始，也就是2i+1處開始
            if(k+1<length && arr[k]<arr[k+1]){//若是左子結點小於右子結點，k指向右子結點
                k++;
            }
            if(arr[k] >temp){//若是子節點大於父節點，將子節點值賦給父節點（不用進行交換）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//將temp值放到最終的位置
    }

    /**
     * 交換元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}
複製代碼

9.4 算法效率

因爲堆排序中初始化堆的過程比較次數較多, 所以它不太適用於小序列。同時因爲屢次任意下標相互交換位置, 相同元素之間本來相對的順序被破壞了, 所以, 它是不穩定的排序。

①. 創建堆的過程, 從length/2 一直處理到0, 時間複雜度爲O(n);

②. 調整堆的過程是沿着堆的父子節點進行調整, 執行次數爲堆的深度, 時間複雜度爲O(lgn);

③. 堆排序的過程由n次第②步完成, 時間複雜度爲O(nlgn).

平均時間複雜度	最好狀況	最壞狀況	空間複雜度
O(nlogn)	O(nlogn)	O(nlogn)	O(1)

10. 總結

從時間複雜度來講：

(1). 平方階O(n²)排序：各種簡單排序：直接插入、直接選擇和冒泡排序；

(2). 線性對數階O(nlog₂n)排序：快速排序、堆排序和歸併排序；

(3). O(n1+§))排序，§是介於0和1之間的常數：希爾排序

(4). 線性階O(n)排序：基數排序，此外還有桶、箱排序。

時間複雜度極限：

當被排序的數有一些性質的時候（好比是整數，好比有必定的範圍），排序算法的複雜度是能夠小於O(nlgn)的。好比：

計數排序 複雜度O( k+n) 要求：被排序的數是0~k範圍內的整數

基數排序 複雜度O( d(k+n) ) 要求：d位數，每一個數位有k個取值

桶排序 複雜度 O( n ) （平均） 要求：被排序數在某個範圍內，而且服從均勻分佈

可是，當被排序的數不具備任何性質的時候，通常使用基於比較的排序算法，而基於比較的排序算法時間複雜度的下限必須是O( nlgn) 。參考不少高效排序算法的代價是 nlogn，難道這是排序算法的極限了嗎？

說明 當原表有序或基本有序時，直接插入排序和冒泡排序將大大減小比較次數和移動記錄的次數，時間複雜度可降至O（n）；

而快速排序則相反，當原表基本有序時，將蛻化爲冒泡排序，時間複雜度提升爲O（n2）；

原表是否有序，對簡單選擇排序、堆排序、歸併排序和基數排序的時間複雜度影響不大。

11.參考資料

1. 八大排序算法總結與java實現
2. 圖解排序算法(三)之堆排序