8大排序算法圖文講解

排序有內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。

我們這里說說八大排序就是內部排序。

    

    當n較大，則應采用時間復雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸並排序序。

   快速排序：是目前基於比較的內部排序中被認為是最好的方法，當待排序的關鍵字是隨機分布時，快速排序的平均時間最短；

算法一：插入排序

 

插入排序示意圖

插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。

算法步驟：

1）將第一待排序序列第一個元素看做一個有序序列，把第二個元素到最后一個元素當成是未排序序列。

2）從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的后面。）

代碼實現：

public class InsertSort {
    
    public static void sort(int[] num){
        int i,j,min,temp;
        for(i=0;i<num.length;i++){
            min=i;//將當前下標定義為最小值下標
            for(j=i+1;j<num.length;j++){
                if (num[min]>num[j]) {
                    min=j;//如果有小於當前最小值的關鍵字，將此關鍵字的下標賦值給min
                }
            }
            if (i!=min) {//若min不等於i，說明上面相互比較的為true，即有最小值，交換
                temp=num[i];
                num[i]=num[min];
                num[min]=temp;
            }
        }
        for (int k : num) {
            System.out.println(k);
        }
        
    }
    
    
    public static void main(String[] args) {
        // TODO 自動生成的方法存根
        int[] num={5,2,4,6,8,9,7,1,3,0};
        sort(num);
    }
}

 算法二：希爾排序

希爾排序示意圖

 

 

給定實例的shell排序的排序過程

假設待排序文件有10個記錄，其關鍵字分別是：

49，38，65，97，76，13，27，49，55，04。

增量序列的取值依次為：

5，3，1

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

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

• 插入排序在對幾乎已經排好序的數據操作時， 效率高， 即可以達到線性排序的效率
• 但插入排序一般來說是低效的， 因為插入排序每次只能將數據移動一位

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

算法步驟：

1）選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；

2）按增量序列個數k，對序列進行k 趟排序；

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

代碼實現：

public class ShellSort {
    //希爾排序
    public static void sort(int[] a) {
        // 希爾排序
        int d = a.length;
        while (true) {
            d = d / 2;
            for (int x = 0; x < d; x++) {
                for (int i = x + d; i < a.length; i = i + d) {
                    int temp = a[i];
                    int j;
                    for (j = i - d; j >= 0 && a[j] > temp; j = j - d) {
                        a[j + d] = a[j];
                    }
                    a[j + d] = temp;
                }
            }
            if (d == 1) {
                break;
            }
        }
        
        for (int k : a) {
            System.out.println(k);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = { 5, 2, 4, 6, 8, 9, 7, 1, 3, 0 };
        // int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
        sort(a);
    }

}

算法三：選擇排序

選擇排序示意圖

選擇排序(Selection sort)也是一種簡單直觀的排序算法。

算法步驟：

1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2）再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。

3）重復第二步，直到所有元素均排序完畢。

代碼實現：

/**
 * 選擇一個min做基准和其他的數據相互比較,如果比較的數大則把當前的數的賦值給min
 * 以此類推
 * @author Administrator
 *
 */
public class SelectSort {
    //簡單選擇排序，選擇一個min做基准和其他的數據相互比較
    public static void sort(int[] num){
        int i,j,min,temp;
        for(i=0;i<num.length;i++){
            min=i;//將當前下標定義為最小值下標
            for(j=i+1;j<num.length;j++){
                if (num[min]>num[j]) {
                    min=j;//如果有小於當前最小值的關鍵字，將此關鍵字的下標賦值給min
                }
            }
            if (i!=min) {//若min不等於i，說明上面相互比較的為true，即有最小值，交換
                temp=num[i];
                num[i]=num[min];
                num[min]=temp;
            }
        }
        for (int k : num) {
            System.out.println(k);
        }
        
    }
    
    public static void main(String args[]){
        int[] num={5,2,4,6,8,9,7,1,3,0};
        sort(num);

    }
}

 算法四：冒泡排序

冒泡排序示意圖

 冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

算法步驟：

1）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

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

3）針對所有的元素重復以上的步驟，除了最后一個。

4）持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

代碼實現：

/**
 * 相鄰數據兩兩比較，大的排上面，小的排下面 第一次可排出最小的值
 * 第二次排出第二小的值
 * 第三次排出第三小的值
 * 以此類推排出順序
 * @author Administrator
 *
 */
public class BubbleSort {
    
    //初級版
    public static void sort1(int[] num){
        int i,j,temp;
        for(i=0;i<num.length;i++){
            for(j=i+1;j<num.length;j++){
                if (num[i]>num[j]) {
                    temp=num[i];
                    num[i]=num[j];
                    num[j]=temp;
                }
            }
        }
        for (int k : num) {
            System.out.println(k);
        }
        
    }
    //中級版
    public static void sort2(int[] num){
        int i,j,temp;
        for(i=0;i<num.length;i++){
            for(j=num.length-1;j>i;j--){
                if (num[j-1]>num[j]) {
                    temp=num[j-1];
                    num[j-1]=num[j];
                    num[j]=temp;
                }
            }
        }
        for (int k : num) {
            System.out.println(k);
        }
        
    }
    //終極版
    public static void sort3(int[] num){
        int i,j,temp;
        boolean flag=true;
        for(i=0;i<num.length&&flag;i++){
            flag=false;
            for(j=num.length-1;j>i;j--){
                if (num[j-1]>num[j]) {
                    temp=num[j-1];
                    num[j-1]=num[j];
                    num[j]=temp;
                    flag=true;
                }
            }
        }
        for (int k : num) {
            System.out.println(k);
        }
        
    }
    
    
    public static void main(String args[]){
        int[] num={5,2,4,6,8,9,7,1,3,0};
//        sort1(num);
//        sort2(num);
        sort3(num);
    }
    
}

 算法五：歸並排序

歸並排序示意圖

歸並排序（MERGE-SORT）是利用歸並的思想實現的排序方法，該算法采用經典的分治（divide-and-conquer）策略（分治法將問題分(divide)成一些小的問題然后遞歸求解，而治(conquer)的階段則將分的階段得到的各答案"修補"在一起，即分而治之)。

分而治之

 　　可以看到這種結構很像一棵完全二叉樹，本文的歸並排序我們采用遞歸去實現（也可采用迭代的方式去實現）。分階段可以理解為就是遞歸拆分子序列的過程，遞歸深度為log₂n。

合並相鄰有序子序列

　　再來看看治階段，我們需要將兩個已經有序的子序列合並成一個有序序列，比如上圖中的最后一次合並，要將[4,5,7,8]和[1,2,3,6]兩個已經有序的子序列，合並為最終序列[1,2,3,4,5,6,7,8]，來看下實現步驟。

代碼實現

package sortdemo;

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/12/8.
 */
public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一個長度等於原數組長度的臨時數組，避免遞歸中頻繁開辟空間
        sort(arr,0,arr.length-1,temp);
    }
    private static void sort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左邊歸並排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右邊歸並排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//將兩個有序子數組合並操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指針
        int j = mid+1;//右序列指針
        int t = 0;//臨時數組指針
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//將左邊剩余元素填充進temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//將右序列剩余元素填充進temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //將temp中的元素全部拷貝到原數組中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

執行結果

[1, 2, 3, 4, 5, 6, 7, 8, 9]

最后

　　歸並排序是穩定排序，它也是一種十分高效的排序，能利用完全二叉樹特性的排序一般性能都不會太差。java中Arrays.sort()采用了一種名為TimSort的排序算法，就是歸並排序的優化版本。從上文的圖中可看出，每次合並操作的平均時間復雜度為O(n)，而完全二叉樹的深度為|log2n|。總的平均時間復雜度為O(nlogn)。而且，歸並排序的最好，最壞，平均時間復雜度均為O(nlogn)。

 算法六：快速排序

假如我們的計算機每秒鍾可以運行10億次，那么對1億個數進行排序，桶排序則只需要0.1秒，而冒泡排序則需要1千萬秒，達到115天之久，是不是很嚇人。那有沒有既不浪費空間又可以快一點的排序算法呢？那就是“快速排序”啦！光聽這個名字是不是就覺得很高端呢。

 

        假設我們現在對“6  1  2 7  9  3  4  5 10  8”這個10個數進行排序。首先在這個序列中隨便找一個數作為基准數（不要被這個名詞嚇到了，就是一個用來參照的數，待會你就知道它用來做啥的了）。為了方便，就讓第一個數6作為基准數吧。接下來，需要將這個序列中所有比基准數大的數放在6的右邊，比基准數小的數放在6的左邊，類似下面這種排列。

       3  1  2 5  4  6  9 7  10  8

 

        在初始狀態下，數字6在序列的第1位。我們的目標是將6挪到序列中間的某個位置，假設這個位置是k。現在就需要尋找這個k，並且以第k位為分界點，左邊的數都小於等於6，右邊的數都大於等於6。想一想，你有辦法可以做到這點嗎？

 

        給你一個提示吧。請回憶一下冒泡排序，是如何通過“交換”，一步步讓每個數歸位的。此時你也可以通過“交換”的方法來達到目的。具體是如何一步步交換呢？怎樣交換才既方便又節省時間呢？先別急着往下看，拿出筆來，在紙上畫畫看。我高中時第一次學習冒泡排序算法的時候，就覺得冒泡排序很浪費時間，每次都只能對相鄰的兩個數進行比較，這顯然太不合理了。於是我就想了一個辦法，后來才知道原來這就是“快速排序”，請允許我小小的自戀一下(^o^)。

 

        方法其實很簡單：分別從初始序列“6  1  2 7  9  3  4  5 10  8”兩端開始“探測”。先從右往左找一個小於6的數，再從左往右找一個大於6的數，然后交換他們。這里可以用兩個變量i和j，分別指向序列最左邊和最右邊。我們為這兩個變量起個好聽的名字“哨兵i”和“哨兵j”。剛開始的時候讓哨兵i指向序列的最左邊（即i=1），指向數字6。讓哨兵j指向序列的最右邊（即j=10），指向數字8。

 

       首先哨兵j開始出動。因為此處設置的基准數是最左邊的數，所以需要讓哨兵j先出動，這一點非常重要（請自己想一想為什么）。哨兵j一步一步地向左挪動（即j--），直到找到一個小於6的數停下來。接下來哨兵i再一步一步向右挪動（即i++），直到找到一個數大於6的數停下來。最后哨兵j停在了數字5面前，哨兵i停在了數字7面前。

 

 

 

 

       現在交換哨兵i和哨兵j所指向的元素的值。交換之后的序列如下。

        6  1  2  5  9 3  4  7  10  8

 

 

 

        到此，第一次交換結束。接下來開始哨兵j繼續向左挪動（再友情提醒，每次必須是哨兵j先出發）。他發現了4（比基准數6要小，滿足要求）之后停了下來。哨兵i也繼續向右挪動的，他發現了9（比基准數6要大，滿足要求）之后停了下來。此時再次進行交換，交換之后的序列如下。

        6  1  2 5  4  3  9  7 10  8

 

        第二次交換結束，“探測”繼續。哨兵j繼續向左挪動，他發現了3（比基准數6要小，滿足要求）之后又停了下來。哨兵i繼續向右移動，糟啦！此時哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。說明此時“探測”結束。我們將基准數6和3進行交換。交換之后的序列如下。

        3  1 2  5  4  6  9 7  10  8

 

 

        到此第一輪“探測”真正結束。此時以基准數6為分界點，6左邊的數都小於等於6，6右邊的數都大於等於6。回顧一下剛才的過程，其實哨兵j的使命就是要找小於基准數的數，而哨兵i的使命就是要找大於基准數的數，直到i和j碰頭為止。

 

        OK，解釋完畢。現在基准數6已經歸位，它正好處在序列的第6位。此時我們已經將原來的序列，以6為分界點拆分成了兩個序列，左邊的序列是“3  1 2  5  4”，右邊的序列是“9  7  10  8”。接下來還需要分別處理這兩個序列。因為6左邊和右邊的序列目前都還是很混亂的。不過不要緊，我們已經掌握了方法，接下來只要模擬剛才的方法分別處理6左邊和右邊的序列即可。現在先來處理6左邊的序列現吧。

 

        左邊的序列是“3  1  2 5  4”。請將這個序列以3為基准數進行調整，使得3左邊的數都小於等於3，3右邊的數都大於等於3。好了開始動筆吧。

 

        如果你模擬的沒有錯，調整完畢之后的序列的順序應該是。

        2  1  3  5  4

 

        OK，現在3已經歸位。接下來需要處理3左邊的序列“2 1”和右邊的序列“5 4”。對序列“2 1”以2為基准數進行調整，處理完畢之后的序列為“1 2”，到此2已經歸位。序列“1”只有一個數，也不需要進行任何處理。至此我們對序列“2 1”已全部處理完畢，得到序列是“1 2”。序列“5 4”的處理也仿照此方法，最后得到的序列如下。

        1  2  3 4  5  6 9  7  10  8

 

        對於序列“9  7  10  8”也模擬剛才的過程，直到不可拆分出新的子序列為止。最終將會得到這樣的序列，如下。

        1  2  3 4  5  6  7  8 9  10

 

        到此，排序完全結束。細心的同學可能已經發現，快速排序的每一輪處理其實就是將這一輪的基准數歸位，直到所有的數都歸位為止，排序就結束了。下面上個霸氣的圖來描述下整個算法的處理過程。

 

 

        快速排序之所比較快，因為相比冒泡排序，每次交換是跳躍式的。每次排序的時候設置一個基准點，將小於等於基准點的數全部放到基准點的左邊，將大於等於基准點的數全部放到基准點的右邊。這樣在每次交換的時候就不會像冒泡排序一樣每次只能在相鄰的數之間進行交換，交換的距離就大的多了。因此總的比較和交換次數就少了，速度自然就提高了。當然在最壞的情況下，仍可能是相鄰的兩個數進行了交換。因此快速排序的最差時間復雜度和冒泡排序是一樣的都是O(N ²)，它的平均時間復雜度為O(NlogN)。

代碼實現：

public class QuickSort {

    public static void quickSort(int arr[], int _left, int _right) {
        int left = _left;
        int right = _right;
        int temp = 0;
        if (left <= right) { // 待排序的元素至少有兩個的情況
            temp = arr[left]; // 待排序的第一個元素作為基准元素
            while (left != right) { // 從左右兩邊交替掃描，直到left = right

                while (right > left && arr[right] >= temp)
                    right--; // 從右往左掃描，找到第一個比基准元素小的元素
                arr[left] = arr[right]; // 找到這種元素arr[right]后與arr[left]交換

                while (left < right && arr[left] <= temp)
                    left++; // 從左往右掃描，找到第一個比基准元素大的元素
                arr[right] = arr[left]; // 找到這種元素arr[left]后，與arr[right]交換

            }
            arr[right] = temp; // 基准元素歸位
            quickSort(arr, _left, left - 1); // 對基准元素左邊的元素進行遞歸排序
            quickSort(arr, right + 1, _right); // 對基准元素右邊的進行遞歸排序
        }
    }

    public static void main(String[] args) {
        int array[] = { 10, 5, 3, 1, 7, 2, 8 };
        System.out.println("排序之前：");
        for (int element : array) {
            System.out.print(element + " ");
        }

        quickSort(array, 0, array.length - 1);

        System.out.println("\n排序之后：");
        for (int element : array) {
            System.out.print(element + " ");
        }

    }

}