1. 氣泡排序

1.1 演算法原理：

S1：從待排序序列的起始位置開始，從前往後依次比較各個位置和其後一位置的大小並執行S2。
S2：如果當前位置的值大於其後一位置的值，就把他倆的值交換（完成一次全序列比較後，序列最後位置的值即此序列最大值，所以其不需要再參與冒泡）。
S3：將序列的最後位置從待排序序列中移除。若移除後的待排序序列不為空則繼續執行S1，否則冒泡結束。

1.2 演算法實現（Java）：

1.2.1 基礎實現：

public static void bubbleSort(int[] array) {
    int len = array.length;
    for (int i = 0; i < len; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j + 1];
                array[j + 1] = array[j];
                array[j] = temp;
            }
        }
    }
}

1.2.2 演算法優化：

若某一趟排序中未進行一次交換，則排序結束

public static void bubbleSort(int[] array) {
    int len = array.length;
    boolean flag = true;
    while (flag) {
        flag = false;
        for (int i = 0; i < len - 1; i++) {
            if (array[i] > array[i + 1]) {
                int temp = array[i + 1];
                array[i + 1] = array[j];
                array[i] = temp;
                flag = true;
            }
        }
        len--;
    }
}

2. 快速排序

2.1 演算法原理：

快速排序是對氣泡排序的一種改進。基本思想是：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此實現整個資料變成有序序列。

2.2 演算法實現（Java）：

public static void quickSort(int[] array, int left, int right) {
    if (left < right) {
        int pivot = array[left];
        int low = left;
        int high = right;
        while (low < high) {
            while (low < high && array[high] >= pivot) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= pivot) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = pivot;
        quickSort(array, left, low - 1);
        quickSort(array, low + 1, right);
    }
}

3. 直接插入排序

3.1 演算法原理：

插入排序的基本方法是：每步將一個待排序序列按資料大小插到前面已經排序的序列中的適當位置，直到全部資料插入完畢為止。
假設有一組無序序列 R0, R1, … , Rn−1：
(1) 將這個序列的第一個元素R0視為一個有序序列；
(2) 依次把 R1, R2, … , Rn−1 插入到這個有序序列中；
(3) 將Ri插入到有序序列中時，前 i-1 個數是有序的，將Ri和R0 ~ Ri−1從後往前進行比較，確定要插入的位置。

3.2 演算法實現（Java）：

public static void insertSort(int[] array) {
    for (int i = 1, len = array.length; i < len; i++) {
        if (array[i] < array[i - 1]) {
            int temp = array[i];
            int j;
            for (j = i - 1; j >= 0 && temp < array[j]; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = temp;
        }

    }
}

4. Shell排序

4.1 演算法原理：

希爾排序是一種插入排序演算法，又稱作縮小增量排序。是對直接插入排序演算法的改進。其基本思想是：
先取一個小於n的整數h1作為第一個增量，把全部資料分成h1個組。所有距離為h1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然後，取第二個增量h2<h1重複上述的分組和排序，直至所取的增量ht=1(ht<ht−1<…<h2<h1），即所有記錄放在同一組中進行直接插入排序為止。該方法實質上是一種分組插入方法。

4.2 演算法實現（Java）：

public static void shellSort(int[] array) {
    int n = array.length;
    int h;
    for (h = n / 2; h > 0; h /= 2) {
        for (int i = h; i < n; i++) {
            for (int j = i - h; j >= 0; j -= h) {
                if (array[j] > array[j + h]) {
                    int temp = array[j];
                    array[j] = array[j + h];
                    array[j + h] = temp;
                }
            }
        }
    }
}

5. 直接選擇排序

5.1 演算法原理：

直接選擇排序是一種簡單的排序方法，它的基本思想是：
第一次從R[0]~R[n-1]中選取最小值，與R[0]交換，
第二次從R[1]~R[n-1]中選取最小值，與R[1]交換，
….，
第i次從R[i-1]~R[n-1]中選取最小值，與R[i-1]交換，
…..，
第n-1次從R[n-2]~R[n-1]中選取最小值，與R[n-2]交換，
共通過n-1次，得到一個從小到大排列的有序序列。

5.2 演算法實現（Java）：

public static void selectSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (array[minIndex] > array[j]) {
                minIndex = j;
            }
        }
        if (i != minIndex) {
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
}

6. 堆排序

6.1 演算法原理：

6.1.1 二叉堆定義：

二叉堆是完全二叉樹或近似完全二叉樹。二叉堆滿足兩個特性：
1）父結點的鍵值總是大於或等於（小於或等於）任何一個子節點的鍵值。
2）每個結點的左子樹和右子樹都是一個二叉堆。
當父結點的鍵值總是大於或等於任何一個子節點的鍵值時為大根堆。當父結點的鍵值總是小於或等於任何一個子節點的鍵值時為小根堆。下面展示一個小根堆：
這裡寫圖片描述
由於其它幾種堆（二項式堆，斐波納契堆等）用的較少，一般將二叉堆就簡稱為堆。

6.1.2 堆的儲存：

一般都用陣列來表示堆，i結點的父結點下標就為(i – 1) / 2。它的左右子結點下標分別為2 * i + 1和2 * i + 2。如第0個結點左右子結點下標分別為1和2。
這裡寫圖片描述

6.1.3 堆的插入：

每次插入都是將新資料放在陣列最後。可以發現從這個新資料的父結點到根結點必然為一個有序的數列，然後將這個新資料插入到這個有序資料中。

6.1.4 堆排序：

堆排序(Heapsort)是指利用堆積樹（堆）這種資料結構所設計的一種排序演算法，它是選擇排序的一種。可以利用陣列的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大於其父節點的值，即A[PARENT[i]] >= A[i]，小根堆則相反。
堆排序利用了大根堆（或小根堆）堆頂記錄的關鍵字最大（或最小）這一特徵，使得在當前無序區中選取最大（或最小）關鍵字的記錄變得簡單。
（1）用大根堆排序的基本思想
① 先將初始陣列R1...Rn建成一個大根堆，此堆為初始的無序區
② 再將最大的元素R1（即堆頂）和無序區的最後一個記錄Rn交換，由此得到新的無序區R1...Rn−1和有序區Rn，且滿足

八大常用排序演算法詳細分析 包括複雜度，原理和實現