面試官：手撕十大排序算法，你會幾種？

時間 2021-03-02

標籤 java git 面試算法 api 數組服務器網絡數據結構架構欄目快樂工作简体版

原文原文鏈接

做者： C you again，從事軟件開發努力在IT搬磚路上的技術小白java

公衆號： 【C you again】，分享計算機類畢業設計源碼、IT技術文章、遊戲源碼、網頁模板、程序人生等等。公衆號回覆【粉絲】進博主技術羣，與大佬交流，領取乾貨學習資料
關於轉載：歡迎轉載博主文章，轉載時代表出處
求贊環節：創做不易，記得點贊+評論+轉發謝謝你一路支持git

原文連接：面試官：手撕十大排序算法，你會幾種？

在前面三期，介紹了動態規劃的兩個主要特性：交疊子問題和最優子結構，並用七種方式求解第n項斐波那契數，感覺了算法的強大，你是否也領略到它的精髓呢？面試

《深刻淺出理解動態規劃（一） | 交疊子問題》算法

《深刻淺出理解動態規劃（二） | 最優子結構》api

《用x種方式求第n項斐波那契數，99%的人只會第一種》數組

今天咱們就來討論面試官最喜歡問到的排序算法吧，從冒泡排序、選擇排序、插入排序等十大排序算法的排序步驟、代碼實現兩個方面入手，完全搞清實現原理，保證面試道路一路暢通。服務器

01 排序算法的概述

所謂排序算法，就是經過特定的算法因式將一組或多組數據按照必定模式進行從新排序。網絡

這種新序列遵循着必定的規則，體現出必定的規律，所以，經處理後的數據便於篩選和計算，大大提升了計算效率。數據結構

02 排序算法的分類

03評價標準

（1）時間複雜度：即從序列的初始狀態到通過排序算法的變換移位等操做變到最終排序好的結果狀態的過程所花費的時間度量。架構

（2）空間複雜度：就是從序列的初始狀態通過排序移位變換的過程一直到最終的狀態所花費的空間開銷。

（3）穩定性：穩定性是無論考慮時間和空間必需要考慮的問題，每每也是很是重要的影響選擇的因素。

04 實現步驟與代碼

冒泡排序（Bubble Sort）

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

（1）算法步驟

步驟1：比較相鄰的元素。若是第一個比第二個大，就交換他們兩個；
步驟2：對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。這步作完後，最後的元素會是最大的數；
步驟3：針對全部的元素重複以上的步驟，除了最後一個；
步驟4：重複步驟1~3，直到排序完成；

（2）代碼實現

public class BubbleSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i++) {
            // 設定一個標記，若爲true，則表示這次循環沒有進行交換，也就是待排序列已經有序，排序已經完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
        return arr;
    }
}

選擇排序（Selection Sort）

選擇排序是一種簡單直觀的排序算法，不管什麼數據進去都是 O(n²) 的時間複雜度。因此用到它的時候，數據規模越小越好。

（1）算法步驟

步驟1：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
步驟2：再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾；
步驟3：重複步驟2，直到全部元素均排序完畢；

（2）代碼實現

public class SelectionSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 總共要通過 N-1 輪比較
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每輪須要比較的次數 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 記錄目前能找到的最小值元素的下標
                    min = j;
                }
            }

            // 將找到的最小值和i位置所在的值進行交換
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}

插入排序（Insertion Sort）

插入排序的算法描述是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，一般採用in-place排序（即只需用到O(1)的額外空間的排序），於是在從後向前掃描過程當中，須要反覆把已排序元素逐步向後挪位，爲最新元素提供插入空間。

（1）算法步驟

步驟1：從第一個元素開始，該元素能夠認爲已經被排序；
步驟2：取出下一個元素，在已經排序的元素序列中從後向前掃描；
步驟3：若是該元素（已排序）大於新元素，將該元素移到下一位置；
步驟4：重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
步驟5：將新元素插入到該位置後；
步驟6：重複步驟2~5；

（2）代碼實現

public class InsertSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 從下標爲1的元素開始選擇合適的位置插入，由於下標爲0的只有一個元素，默認是有序的
        for (int i = 1; i < arr.length; i++) {

            // 記錄要插入的數據
            int tmp = arr[i];

            // 從已經排序的序列最右邊的開始比較，找到比其小的數
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }

            // 存在比其小的數，插入
            if (j != i) {
                arr[j] = tmp;
            }

        }
        return arr;
    }
}

希爾排序（Shell Sort）

希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。

希爾排序是基於插入排序的如下兩點性質而提出改進方法的：

插入排序在對幾乎已經排好序的數據操做時，效率高，便可以達到線性排序的效率；
但插入排序通常來講是低效的，由於插入排序每次只能將數據移動一位；

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

（1）算法步驟

步驟1：選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
步驟2：按增量序列個數 k，對序列進行 k趟排序；
步驟3：每趟排序，根據對應的增量 ti，將待排序列分割成若干長度爲 m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲 1時，整個序列做爲一個表來處理，表長度即爲整個序列的長度；

（2）代碼實現

public class ShellSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int gap = 1;
        while (gap < arr.length) {
            gap = gap * 3 + 1;
        }

        while (gap > 0) {
            for (int i = gap; i < arr.length; i++) {
                int tmp = arr[i];
                int j = i - gap;
                while (j >= 0 && arr[j] > tmp) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j + gap] = tmp;
            }
            gap = (int) Math.floor(gap / 3);
        }

        return arr;
    }
}

歸併排序（Merge Sort）

歸併排序是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個很是典型的應用。歸併排序是一種穩定的排序方法。將已有序的子序列合併，獲得徹底有序的序列；即先使每一個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲2-路歸併。

和選擇排序同樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，由於始終都是O(n log n）的時間複雜度。代價是須要額外的內存空間。

（1）算法步驟

步驟1：把長度爲n的輸入序列分紅兩個長度爲n/2的子序列；
步驟2：對這兩個子序列分別採用歸併排序；
步驟3：將兩個排序好的子序列合併成一個最終的排序序列；

（2）代碼實現

public class MergeSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        if (arr.length < 2) {
            return arr;
        }
        int middle = (int) Math.floor(arr.length / 2);

        int[] left = Arrays.copyOfRange(arr, 0, middle);
        int[] right = Arrays.copyOfRange(arr, middle, arr.length);

        return merge(sort(left), sort(right));
    }

    protected int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }

        return result;
    }

}

快速排序（Quick Sort）

快速排序是由東尼·霍爾所發展的一種排序算法。在平均情況下，排序n個項目要 Ο(n log n) 次比較。在最壞情況下則須要 Ο(n^2) 次比較，但這種情況並不常見。事實上，快速排序一般明顯比其餘 Ο(nlogn) 算法更快，由於它的內部循環（inner loop）能夠在大部分的架構上頗有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分爲兩個子串行（sub-lists）。

（1）算法步驟

步驟1：從數列中挑出一個元素，稱爲 "基準"（pivot）；
步驟2：從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區退出以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做；
步驟3：遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序；

（2）代碼實現

public class QuickSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return quickSort(arr, 0, arr.length - 1);
    }

    private int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    private int partition(int[] arr, int left, int right) {
        // 設定基準值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

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

}

堆排序（Heap Sort）

堆排序是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似徹底二叉樹的結構，並同時知足堆積的性質：即子結點的鍵值或索引老是小於（或者大於）它的父節點。堆排序能夠說是一種利用堆的概念來排序的選擇排序。分爲兩種方法：

大頂堆：每一個節點的值都大於或等於其子節點的值，在堆排序算法中用於升序排列；
小頂堆：每一個節點的值都小於或等於其子節點的值，在堆排序算法中用於降序排列；

堆排序的平均時間複雜度爲 O(n log n)。

（1）算法步驟

步驟1：將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆爲初始的無序區；
步驟2：將堆頂元素R[1]與最後一個元素R[n]交換，此時獲得新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且知足R[1,2…n-1]<=R[n]；
步驟3：因爲交換後新的堆頂R[1]可能違反堆的性質，所以須要對當前無序區(R1,R2,……Rn-1)調整爲新堆，而後再次將R[1]與無序區最後一個元素交換，獲得新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成；

（2）代碼實現

public class HeapSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int len = arr.length;

        buildMaxHeap(arr, len);

        for (int i = len - 1; i > 0; i--) {
            swap(arr, 0, i);
            len--;
            heapify(arr, 0, len);
        }
        return arr;
    }

    private void buildMaxHeap(int[] arr, int len) {
        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
            heapify(arr, i, len);
        }
    }

    private void heapify(int[] arr, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, largest, len);
        }
    }

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

}

計數排序（Counting Sort）

計數排序的核心在於將輸入的數據值轉化爲鍵存儲在額外開闢的數組空間中。做爲一種線性時間複雜度的排序，計數排序要求輸入的數據必須是有肯定範圍的整數。

計數排序是一種穩定的排序算法。計數排序使用一個額外的數組C，其中第i個元素是待排序數組A中值等於i的元素的個數。而後根據數組C來將A中的元素排到正確的位置。它只能對整數進行排序。

（1）算法步驟

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

（2）代碼實現

public class CountingSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxValue = getMaxValue(arr);

        return countingSort(arr, maxValue);
    }

    private int[] countingSort(int[] arr, int maxValue) {
        int bucketLen = maxValue + 1;
        int[] bucket = new int[bucketLen];

        for (int value : arr) {
            bucket[value]++;
        }

        int sortedIndex = 0;
        for (int j = 0; j < bucketLen; j++) {
            while (bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
        return arr;
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

}

桶排序（Bucket Sort）

桶排序是計數排序的升級版。它利用了函數的映射關係，高效與否的關鍵就在於這個映射函數的肯定。爲了使桶排序更加高效，咱們須要作到這兩點：

在額外空間充足的狀況下，儘可能增大桶的數量
使用的映射函數可以將輸入的N個數據均勻的分配到K個桶中

同時，對於桶中元素的排序，選擇何種比較排序算法對於性能的影響相當重要。

（1）算法步驟

步驟1：人爲設置一個BucketSize，做爲每一個桶所能放置多少個不一樣數值（例如當BucketSize==5時，該桶能夠存放｛1,2,3,4,5｝這幾種數字，可是容量不限，便可以存放100個3）；
步驟2：遍歷輸入數據，而且把數據一個一個放到對應的桶裏去；
步驟3：對每一個不是空的桶進行排序，可使用其它排序方法，也能夠遞歸使用桶排序；
步驟4：從不是空的桶裏把排好序的數據拼接起來；

注意，若是遞歸使用桶排序爲各個桶排序，則當桶數量爲1時要手動減少BucketSize增長下一循環桶的數量，不然會陷入死循環，致使內存溢出；

（2）代碼實現

/**
     * 桶排序
     *
     * @param array
     * @param bucketSize
     * @return
     */
    public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
        if (array == null || array.size() < 2)
            return array;
        int max = array.get(0), min = array.get(0);
        // 找到最大值最小值
        for (int i = 0; i < array.size(); i++) {
            if (array.get(i) > max)
                max = array.get(i);
            if (array.get(i) < min)
                min = array.get(i);
        }
        int bucketCount = (max - min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < array.size(); i++) {
            bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketSize == 1) { // 若是待排序數組中有重複數字時
                for (int j = 0; j < bucketArr.get(i).size(); j++)
                    resultArr.add(bucketArr.get(i).get(j));
            } else {
                if (bucketCount == 1)
                    bucketSize--;
                ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
                for (int j = 0; j < temp.size(); j++)
                    resultArr.add(temp.get(j));
            }
        }
        return resultArr;
    }

基數排序（Radix Sort）

基數排序也是非比較的排序算法，對每一位進行排序，從最低位開始排序，複雜度爲O(kn),爲數組長度，k爲數組中的數的最大的位數；

基數排序是按照低位先排序，而後收集；再按照高位排序，而後再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最後的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。基數排序基於分別排序，分別收集，因此是穩定的。

（1）算法步驟

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

（2）代碼實現

/**
 * 基數排序
 */
public class RadixSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxDigit = getMaxDigit(arr);
        return radixSort(arr, maxDigit);
    }

    /**
     * 獲取最高位數
     */
    private int getMaxDigit(int[] arr) {
        int maxValue = getMaxValue(arr);
        return getNumLenght(maxValue);
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

    protected int getNumLenght(long num) {
        if (num == 0) {
            return 1;
        }
        int lenght = 0;
        for (long temp = num; temp != 0; temp /= 10) {
            lenght++;
        }
        return lenght;
    }

    private int[] radixSort(int[] arr, int maxDigit) {
        int mod = 10;
        int dev = 1;

        for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
            // 考慮負數的狀況，這裏擴展一倍隊列數，其中 [0-9]對應負數，[10-19]對應正數 (bucket + 10)
            int[][] counter = new int[mod * 2][0];

            for (int j = 0; j < arr.length; j++) {
                int bucket = ((arr[j] % mod) / dev) + mod;
                counter[bucket] = arrayAppend(counter[bucket], arr[j]);
            }

            int pos = 0;
            for (int[] bucket : counter) {
                for (int value : bucket) {
                    arr[pos++] = value;
                }
            }
        }

        return arr;
    }

    /**
     * 自動擴容，並保存數據
     *
     * @param arr
     * @param value
     */
    private int[] arrayAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }
}