死磕算法第三彈——排序算法(1)

時間  2019-11-30
標籤 算法 第三 排序算法 简体版
原文   原文鏈接

本文整理來源 《輕鬆學算法——互聯網算法面試寶典》/趙燁 編著java

算法基礎

對於算法性能分析來講，除了時間複雜度，仍是有空間複雜度、穩定性等指標。而咱們平時說的算法的複雜度能夠分爲兩個部分：時間複雜度和空間複雜度。面試

時間複雜度

在科學計算中，算法的時間複雜度是一個函數，它定量地描述了一個算法的運行時間。時間複雜度一般一個大$O$符號來表示，不包括這個函數低階項和首項係數。算法

時間複雜度是漸近的，考慮的是這個值趨近於無窮時的狀況。好比一個算法的執行時間爲$3{ n }^{ 2 } + 2n + 3$，這裏咱們用大$O$符號來表示時，不考慮低階項，也就是隻考慮最高階項$3{ n }^{ 2 }$，也不考慮首項的係數，因此咱們會直接將這個算法的時間複雜度表示爲$O({n}^2)$。編程

咱們在計算一個算法的時間複雜度時，須要考慮算法那是否會有更多重嵌套循環（即代碼中包含的循環內部還有一個循環操做），由於嵌套循環勢必會使時間複雜度升階。而對於一個個列表進行循環有限次數的操做，則無需考慮，由於咱們會忽略首項的係數。數組

咱們在計算一個算法的時間複雜度時，首先須要找到一個算法的核心部分，而後根據代碼確認時間複雜度。多線程

通常的時間複雜度按照性能從差到好有這麼幾種：$O({n}^3)$、$O({n}^2)$、$O(nlogn)$、$O(n)$、$O(logn)$、$O(1)$。固然，性能差的狀況可能還有更高的冪數，可是當算法的時間複雜度達到$O({n}^2)$以上時，性能就會至關差，咱們應該尋找更優的方案。固然，對於某些特殊的宣發，可能最優的性能也不會很好。編程語言

另外，$O(nlogn)$、$O(logn)$內部的內容在數學裏是錯誤的，通常應該是$O(log_{2}{n})$等，可是這裏的係數並不在咱們的考慮返回範圍內，因此咱們通常在計算複雜度時直接將其表示成$O(nlogn)$和$O(logn)$。函數

for(int i = 0; i < n; i ++){
    //some code here
    for(int j = 0; j < n; j ++){
        //some code here
        for(int k = 0; k < n; k++){
            //some code here
        }
    }
}

這段代碼是個三重嵌套循環代碼，n通常指算法的規模，很容易推斷出這段代碼的時間複雜度是$O({n}^3)$。性能

若是是兩重的嵌套循環，那麼時間複雜度是$O({n}^2)$；若是隻有一重循環，那麼時間複雜度是$O({n})$。何時會出現$O(nlogn)$呢？學習

for(int i = 0; i < n; i ++){
    for(int j = i; j < n; j ++){
    }
}

咱們發現，在內層循環中j的起始量是i，隨着每次循環i的增長，j的一層循環執行的次數將愈來愈少。對於這種狀況，咱們把時間複雜度稱爲$O(nlogn)$。

通常咱們把下面這段代碼的時間複雜度稱爲$O(logn)$的時間複雜度，並將這種狀況稱爲對數階，性能要優於$O(n)$。

for(int i = 0; i < n; i *= 2){
}

性能好的算法的時間複雜度爲$O(1)$，也就是執行的有限次的操做以後達到目標。好比一些計算類型的代碼或者交換值的代碼等。

固然一個算法能不能達到$O(1)$的時間複雜度，要看具體狀況，咱們固然但願程序的性能可以達到最優，全部算法的時間複雜度可以低於$O({n}^2)$通常來講就已經很不錯了。不要忘了，算法的性能除了考慮時間複雜度外還要考慮空間複雜度，在大多數狀況下旺旺須要在時間複雜度和空間複雜度之間進行權衡。

咱們在上面提到的狀況都是隻有一個規模參數，有時規模參數也可能有兩個。好比兩層循環的規模不同，咱們假設分別爲m和n，這時咱們通常會發時間複雜度寫爲$O(m*n)$，可是咱們須要明確，若是m和n很是相近，則這個時間複雜度趨於$O({n}^2)$；若是m一般比較小（也就是咱們可以明白m的範圍是多少），則這個時間複雜度趨於$O(n)$。在這兩種時間複雜度下，雖然時間複雜度都是$O(m*n)$，可是真實時間複雜度可能相差很大。

實際上，一個算法的執行時間不可能經過咱們計算得出，必須到機器上真正執行才能知道，並且每次的運行時間不同。可是咱們不必將每一個算法都到機器上運行和測試，而且對於不少算法，咱們經過簡單的分析就能知道性能的好壞，而沒有必要詳細的寫出阿里，因此時間複雜度的計算仍是很是有用的。

時間複雜度其實還分爲平均時間複雜度、最好時間複雜度和最壞時間複雜度。對於一個算法來講，旺旺有不少特殊狀況，通常而言，咱們所說的時間複雜度是指最壞時間複雜度，由於在最壞的狀況下，咱們才能評估一個算法的性能最差會到什麼地步，這樣咱們才能更好地選擇應對算法去解決問題。

空間複雜度

其實咱們在算法分析時，每每會忽略空間發咋讀，可能由於如今計算機的空間已經愈來愈便宜了，成本很低，而一臺計算機的CPU性能始終很可貴到太大的提高。可是空間複雜度做爲一個算法性能指標，也是咱們須要掌握的，這樣可以讓程序在時間和空間上獲得優化，成爲一個好算法。

空間複雜度的表示其實和時間複雜度是同樣的，都用大O符號表示。空間複雜度是一個算法在運行過程當中所消耗的臨時空間的一個度量。

空間複雜度的計算方式和時間複雜度同樣，也不包括這個函數的低階項和首項係數。

咱們通常認爲對於一個算法，自己的數據會消耗必定的空間，可能還須要一些其餘空間，若是須要的其餘空間有限，那麼這個時間複雜度爲$O(1)$。相對地，也有$O(n)$、$O(nlogn)$、$O({n}^2)$。

穩定性

算法性能分析通常分爲時間複雜度分析和空間複雜度分析。另外，在排序算法中會有另外一個指標——穩定性。

在排序算法中，可能在一個列表中存在多個相等的元素，而通過排序以後，這些元素的相對次序保持不變，這是咱們稱這個算法是穩定的。若通過排序以後次序變了，那麼就是不穩定的。

若是算法穩定的，那麼第1個元素排序的結果就能夠被第2個相同的元素排序所使用，也就是說若是算法是穩定的，那麼可能避免多餘的比較。

在某些狀況下，如果值同樣的元素也要保持與原有的相對次序不變，那麼這時就必須用哪一個一個穩定的算法。

快而簡單的排序——桶排序

排序充斥着咱們的生活，好比站隊、排隊買票、考試排名、公司業績排名、將電子郵件按時間排序、QQ好友列表中的會員紅名靠前等等。

什麼是桶排序

桶排序，也叫作箱排序，是一個排序算法，也是全部算法中最快、最簡單的排序算法。其中的思想是咱們首先須要知道全部待排序元素的範圍，而後須要有在這個範圍內的一樣數量的桶，接着把元素放入對應的桶中，最後按順序輸出。

實際的狀況下，一個桶並不老是放同一個元素，不少時候提個桶裏可能會放多個元素，這和散列表有同樣的原理。

除了對一個桶內的元素作鏈表存儲，咱們也可能對桶內的元素繼續使用其餘排序算法進行排序，因此更多時候，桶排序會結合其餘排序算法一塊兒使用。

桶排序的簡單實現

使用數組能夠完成桶排序的實現。而後沒把一個元素往桶中放時，就把數組指定位置的值加1，最終倒序輸出數組的下標，數組每一個位置的值爲幾就輸出幾回下標，這樣就實現桶排序了。

public class BucketSort {

    private int[] buckets;
    private int[] array;

    public BucketSort(int range, int[] array) {
        this.buckets = new int[range];
        this.array = array;
    }

    /**
     * 排序
     */
    public void sort() {
        if (array != null && array.length > 1) {
            for (int anArray : array) {
                buckets[anArray]++;
            }
        }
    }

    /**
     * 從大到小排序
     */
    public void print(){
        //倒敘輸出數組
        for (int i = buckets.length -1 ; i >= 0; i--){
            //元素中的值爲幾，就說明有多少個相同元素，就輸出幾遍
            for (int j = 0; j < buckets[i]; j++){
                System.out.println(i);
            }
        }
    }
}

測試代碼

public class BucketSortTest {

    @Test
    public void main(){
        int[] arrays = {5,9,1,9,5,3,7,6,1};
        BucketSort bucketSort = new BucketSort(11,arrays);
        bucketSort.sort();
        bucketSort.print();
    }

}

桶排序的性能及特色

通便徐實際上只須要遍歷一遍全部待排序元素，而後依次放入指定的位置。好比加上輸出排序的時間，那麼須要遍歷全部的桶，時間複雜度就是$O(n+m)$，其中，n爲待排序的元素的個數，m爲桶的個數。這是至關快速的排序算法，可是對於空間的消耗來講有點太大了。

好比咱們對一、十、100、1000這四個元素排序，那麼咱們須要產能高度爲1001的數組用來排序，若是是對於一、1000、10000排序呢？當元素的跨度返回越大時，空間的浪費就越大，即便只有幾個元素，可是這個範圍纔是空間的大小。因此桶排序的空間複雜度時$O(m)$，其中m爲桶的個數，待排序元素分佈越均勻，也就是說當元素可以很是均勻地填滿全部的桶時，這個空間的利用率是最好的。不過這種狀況並很少見，在多數狀況下，數據並不會均勻的分佈。

經過上線的性能分析，咱們能夠知道桶排序的特色就是速度快、簡單，可是也有相應的弱點，那就是空間利用率低，若是數據的跨度過大，則空間可能沒法承受，或者說這些元素並不合適使用桶排序算法。

桶排序的適用場景

桶排序的適用場景很是名了，那就是在數據分佈相對比較均勻或者數據跨度範圍並非很大時，桶排序的速度仍是至關快且簡單的。

可是當數據跨度很大時，這個空間消耗就會很大；若是數值的範圍特別大，那麼對空間消耗的代價確定也是不切實際的，因此這個算法仍是有必定侷限性。一樣，因爲時間複雜度爲$O(n+m)$，若是m比n大太多，則從時間上來講，性能並非很好。

可是實際上在使用桶排序的過程當中，咱們會使用相似散列表的方式去實現，這時的空間利用率會高不少，同時時間複雜度會有必定的提高，可是效率還不錯。

咱們在開發過程當中，除了對一些要求特別高而且數據分佈較爲均勻的狀況下使用桐柏徐，仍是不多使用桶排序的，因此即便桶排序很簡單、很快，咱們也不多使用它。

桶排序更多地用於一些特定的環境下，好比數據範圍比較侷限或者有一些特定要求，必須經過哈希映射快速獲取某些值、須要統計沒歌詞的數量。可是這一切都須要確認數據的範圍，若是範圍太大，就須要巧妙的解決這個問題或者使用其餘算法了。

冒泡排序

什麼是冒泡排序

冒泡排序(Bubble Sort)是排序算法裏面比較簡單的排序。它重複地走訪要排序的數列，一次比較兩個數據元素，若是順序不對則進行交換，而且一直重複這樣的走訪操做，直到沒有要交換的數據元素爲止。

冒泡排序的原理

首先咱們確定有一個數組，裏面存放着待排序的元素列表，咱們若是須要把比較大的元素排在前面，把小的元素排在後面，那麼須要從尾到頭開始進行比較操做。

  1. 從尾部開始比較相鄰的兩個元素，若是尾部的元素比前面的大，咱們就交換兩個元素的位置。
  2. 往前對每一個相鄰的元素都作這樣的比較、交換操做，這樣的數據組頭部時，第一個元素會變成最大的元素。
  3. 從新從尾部開始第一、2步操做，除了在這以前頭部已經排好的元素。
  4. 繼續對愈來愈少的數據進行比較、交換，知道沒有可比較的數據爲止，排序完成。

這個算法和相識後在操場排隊跑步很像，老師老是說：「高個站在前面，低的站後面」。咱們一開始並不必定會站到準確的位置，接着老師說：「你比前面的高，和前面的換換，還高。再和前面換換」，這樣就找到本身的位置。

冒泡排序的實現算法

首先咱們須要從後往前遍歷待排序的數組，而後重複這個步驟，繼續遍歷剩下的待排序的數列，這樣咱們就須要一個雙重循環去完成這個算法。

public class BubbleSort {
    private int[] array;

    public BubbleSort(int[] array) {
        this.array = array;
    }

    /**
     * 從小到大
     */
    public void sort() {
        int length = array.length;
        if (length > 0) {
            for (int i = 1; i < length; i++) {
                for (int j = 0; j < length - i; j++) {
                    if (array[j] > array[j + 1]) {
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

    /**
     * 從大到小
     */
    public void sort2() {
        int length = array.length;
        if (length > 0) {
            for (int i = length - 1; i > 0; i--) {
                for (int j = length - 1; j > length - 1 - i; j--) {
                    if (array[j] > array[j - 1]) {
                        int temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }
    }

    public void print(){
        for (int anArray : array) {
            System.out.println(anArray);
        }
    }
}

測試代碼

public class BubbleSortTest {

    @Test
    public void main(){
        int[] arrays = {5,9,1,9,5,3,7,6,1};
        BubbleSort bubbleSort = new BubbleSort(arrays);
        bubbleSort.sort2();
        bubbleSort.print();
    }

}

冒泡排序的特色及性能

經過冒泡排序的算法思想，咱們發現冒泡排序算法在每輪排序中會使一個元素排到一端，也就是最終須要n-1輪這樣的排序（n爲待排序的數列的長度），而在每輪排序中都須要對相鄰的每一個元素進行比較，在最壞的狀況下，每次比較以後都須要交換位置，因此這裏的時間複雜度時$O({n}^2)$。其實冒泡排序在最好的狀況下，時間複雜度能夠達到$O(n)$，這固然是在待排序的順序有序的狀況下。在待排序的數列自己就是咱們想到的排序結果時，時間複雜度就是O(n)，由於只須要一輪排序而且不用交換。可是實際上這種狀況不多，因此冒泡排序的平均時間複雜度是$O({n}^2)$。

冒泡排序的使用場景

對於冒泡排序，咱們應該對它的思想進行理解，做爲排序算法學習的引導，讓咱們思惟更加開闊。雖然冒泡排序在咱們的實際工做中並不會用到，其餘排序算法多多少少比冒泡排序算法的性能更高，其實咱們仍是要掌握冒泡排序的思想及實現，而且面試時仍是有可能會用到。

冒泡排序的改進方案

雖然咱們對冒泡排序用的很少，可是正如上面所說，由冒泡排序引發的一些其餘問題仍是挺有意思的。

增長標記位

這裏，咱們增長一個變量來記錄每趟排序中最後一次交換位置，因爲這個位子以後的元素已經不用再交換了，說明後面的元素都完成了排序，因此下次開始能夠直接從尾比較到這個位置，這樣就能保證前面的元素若是自己有序就不用重複比較了。

好比待排序的數列爲十、八、五、一、2，那麼十、八、5自己有序，實際上只須要通過一趟排序交換就能夠完成這個數列的排序操做，性能有時會有必定的提升；又或者中間的一些元素相對有序，有時也可能使總排序趟數少於n-1次。

一次冒2個元素

每趟排序都是交換最大的元素冒到上面去，那麼能夠不能夠在每趟排序中進行正向和反向的兩次冒泡。對於每一趟，在倒着比較出最大的元素以後，在正着比較出較小的元素並使其沉下去，可使排序趟數幾乎減小一半。

快速排序

冒泡排序的時間複雜度時$O({n}^2)$，若是計算機每秒運算10億次，排序1億個數字，那麼桶排序只須要1秒，冒牌排序則須要1千萬秒(也就是115天)，那麼沒有一種排序即省時間又省空間。

什麼是快速排序

其實快速排序是對冒泡排序的一種改進，由C.A.R.Hoare(Charles Antony Richard Hoare，東尼·霍爾)在1962年提出。它的基本思想是：經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據比另外一部分的全部數據要小，在按照這種方法對兩部分數據分別進行快速排序，整個排序過程能夠遞歸排序，使整個數據變成有序序列。

快速排序的原理

排序算法的思想很是簡單，在待排序的數列中，咱們首先要找一個數字做爲基準數（這只是個專用名詞）。爲了方便，咱們通常選第一個數字做爲基準數（其實選擇第幾個並無關係）。接下來咱們須要把這個待排序的數列中小於基準數的元素移動到待排序的數列的左邊，把大於基準數的元素移動到待排序的右邊。這時，左右兩個分區的元素怒就相對有序了；接着把兩個分區的元素按照上面兩個方法繼續對每一個分區找到基準數，而後移動，直到每一個分析只有一個數時爲止。

這是典型的分治思想，即分治法。以4七、2九、7一、9九、7八、1九、2四、47的待排序的數列爲例進行排序，爲了方便區分兩個47，咱們對後面的47增長一個下劃線，即待排序的數列爲4七、2九、7一、9九、7八、1九、2四、++47++。

首先咱們須要在數列中選擇一個基準數，咱們通常選擇中間的一個數或者頭尾的數，這裏直接選擇第一個數47做爲基準書，接着把47小的數字移動到左邊，把比47大的數字移動到右邊，對於相等的數字不作移動。因此實際上咱們須要找到中間的某個位置k，這樣k左邊的值所有比k上的值小，k右邊的值所有比k上的值大。

接下來開始移動元素，其實冒泡排序也涉及到元素的移動，可是那樣移動起來很累，好比把最後一個元素移動到第一個，就須要比較n-1次，同時交換n-1次，效率低，其實，只須要把第一個元素和最後一個元素交換一下就行了，這種思想是否是在排序時能夠借鑑。

快速排序的操做就是這樣：首先從數列的右邊開始往左邊找，咱們設下這個下標爲i，也就是進行行減減操做(i--)，找到第1個比基準數小的值，讓它與基準值交換；接着從左邊開始往右找，設這個下標爲j，而後執行行加加(j++)，找到第一個比基準數大的值，讓它與基準數交換；而後繼續尋找，知道i與j相遇時結束，最後基準值所在的位置便是k的位置，也就是說k左邊的值比k上的值小，而k右邊的值都比k上的值大。

快速排序的實現

其實快速排序時一種比較簡單的思想，就是遞歸。對於每一趟排序都是一種的思想，只不過須要進行排序的數組範圍愈來愈小，使用遞歸實現這種排序最好不過。

public class QuickSort {
    private int[] array;

    public QuickSort(int[] array) {
        this.array = array;
    }

    public void sort() {
        quickSort(array, 0, array.length - 1);
    }

    public void print() {
        for (int i : array) {
            System.out.println(i);
        }
    }

    private void quickSort(int[] src, int begin, int end) {
        if (begin < end) {
            int key = src[begin];
            int i = begin;
            int j = end;

            while (i < j) {
                while (i < j && src[j] > key) {
                    j--;
                }
                if (i < j) {
                    src[i] = src[j];
                    i++;
                }
                while (i < j && src[i] < key) {
                    i++;
                }
                if (i < j) {
                    src[j] = src[i];
                    j--;
                }
            }
            src[i] = key;
            quickSort(src, begin, i - 1);
            quickSort(src, i + 1, end);
        }
    }
}

測試代碼

public class QuickSortTest {

    @Test
    public void main(){
        int[] arrays = {5,9,1,9,5,3,7,6,1};
        QuickSort quickSort = new QuickSort(arrays);
        quickSort.sort();
        quickSort.print();
    }

}

快速排序的特色及性能

快速排序是在冒泡排序的基礎上改進而來的，冒泡排序每次只能交換相鄰的兩個元素，而快速排序是跳躍式的交換，交換的距離很大，所以總的比較和交換次數少了不少，速度也快了很多。

可是快速排序在最壞的狀況下時間複雜度和冒泡排序同樣，是$O({n}^2)$，實際上每次比較都是須要交換，可是這種狀況並不常見。咱們能夠思考一下若是每次比較都須要交換，那麼數列的平均時間複雜度時$O(nlogn)$，實際上大多數的時候，排序的速度要快於這種平均時間複雜度。這種算法其實是一種分治思想，也就是分而治之，把問題分爲一個個的小部分來分別解決，再把結果和組合起來。

快速排序只是使用數組本來的空間進行排序，因此所佔空間應該是常量級的，可是因爲每次劃分以後是遞歸調用，因此遞歸調用在運行的過程當中會消耗掉必定的空間，在通常狀況下的空間複雜度時$O(nlogn)$，在最差的狀況下，若每次只完成了一個元素，那麼空間複雜度爲$O(n)$。因此咱們通常認爲快速排序的空間複雜度爲$O(logn)$

快速排序是一個不穩定的算法，在通過排序以後，可能會相同值的元素的相對位置形成改變。

快速排序基本上被認爲相同數量級的全部排序算法中，平均性能最好的。

快速排序的使用場景

快速排序因爲相對簡單並且性能不錯，因此咱們比較經常使用。在須要對數列排序時，咱們優先選擇快速排序。

快速排序適合在須要針對給定數列進行順序排列時使用，固然有更快的排序算法，可是因爲其餘的一些算法的實現沒有快速排序那麼簡單，可是在n並非很大的狀況下，性能差別並非很大，因此一些複雜的算法雖然在性能上會更有有事，可是在大多數的時候並不常用，這時有快速排序就足夠了。

快速排序的優化

三者取中法

因爲每次選擇基準都尋則第1個，這就會產生一個問題，那就是可能形成每次都須要移動，這樣會使算法的性能不好，趨向於$O({n}^2)$，因此咱們要找出中間位置的值。咱們但願基準值越可以更接近中間位置的值，因此這裏能夠每次使用待排序的數列部分的頭、尾、中間數，在這三個數中取中間大小的那個數做爲基準值，而後進行快速排序，這樣可以對一些狀況下進行優化。

根據規模大小更改算法

因爲快速排序在數據量較小的狀況下，排序性能並未有其餘算法好，因此咱們能夠在待排序的數列區分小於某個值後，採用其餘算法進行排序，而不是繼續使用快速排序，這樣也可以獲得必定的性能提高。這個值通常能夠是5~25，在一些編程語言中使用10或者15這個量。

其餘分區方案考慮

有時，咱們選擇的基準數在數列中可能存在多個，這時咱們能夠考慮改變分區方案，那就是分爲三個區間，除了小於基準數的區間、大於基準數的區間，咱們還能夠交換出一個等於基準數的區間，這樣咱們在以後每次進行遞歸時，救指遞歸小於和大於兩個部分的區間，對於等於基準數的區間就不用考慮了。

並行處理

因爲快速排序對數組中每一小段範圍進行排序，對其餘段並無影響，因此能夠採用如今計算機的多線程來提升效率，這並不算是對算法的優化，只能說是一種對於數量比較多的數據使用快速排序時的一個搞笑解決方案。

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