2. 程式人生 > >經典排序演算法 — java 實現

經典排序演算法 — java 實現

阿新 • • 發佈：2018-12-13

排序演算法的好壞對於效率的影響十分顯著。好的排序演算法排序100萬個整數可能只需要一秒（不考慮硬體因素），不好的排序演算法可能需要一個小時甚至幾個小時。

常見的排序演算法有氣泡排序、插入排序、堆排序、快速排序等，這些排序都屬於基於比較的排序，因此這些演算法的時間複雜度都不能突破 O(NlogN)。

還有另一類非基於比較的排序，包括基數排序、桶排序、計數排序。

氣泡排序一般情況下效率比較低，在此不再贅述。

插入排序（insert sort）

插入排序就像大多數玩家打牌時 排列手中紙牌的情景。從第二張牌開始，根據之前的牌的大小，我們把牌插到合適的位置。這樣在抓下一張牌之前，手中的牌就已經是排好序的了。

如果輸入已經是升序序列，這時時間複雜度為 O(n)。平均來說插入排序時間複雜度為 O(n2)。

注意：雖然氣泡排序和插入排序時間複雜度相同，但一般情況下，插入排序仍然比氣泡排序效率高的多。O(n2) 只是一個理論上的界限，它們的常量部分並不相同，就好像是 n2 和 1000n2 對應的時間複雜度都是 O(n2)。

Java程式碼實現插入排序的思路是將新元素取出，從右到左依次與已排序的元素比較，如果該元素大於新元素，那麼將其移動到新元素的位置，接著繼續比較，直到已排序的元素小於等於新元素，這時將新元素插入至此元素後面的位置，所以此插入排序是穩定的。

需要注意的是，排序演算法是否穩定是由具體演算法決定的，不穩定的演算法在某種條件下可以變為穩定的演算法，而穩定的演算法在某種條件下也可以變為不穩定的演算法，比如比較的邊界的選擇（> 還是 >=）。

public class InsertSort {
    private static int[] randomArray;

    public static int[] factory(int length) {
        Random random = new Random();
        randomArray = new int[length];
        for (int i = 0; i < length; i++) {
            randomArray[i] = random.nextInt(10000);
        }
        return
 
 randomArray;
    }

    public static void insertSort(int[] array) {
        //Instant為Java8新增，用來獲取時間
        Instant begin = Instant.now();
        for (int i = 1; i < array.length; i++) {
            int t = array[i];
            int j;
            for (j = i; j > 0 && array[j - 1] > t; j--)
                array[j] = array[j - 1];
            array[j] = t;
        }
        Instant end = Instant.now();
        System.out.println(Duration.between(begin, end));
    }

    public static void main(String[] args) {
        int[] array = factory(100000);
        insertSort(array);
    }
}

輸出結果：

// ISO 日期時間表示格式
PT4.191S

這裡只進行了100000個整數的排序，只需要4.191s。對於不是很多資料的情況來說，這已經夠用了。但當資料增加到一百萬的時候，在我的機器上用了五分多鐘。在資料量大的時候排序的速度還是不盡如人意。

折半插入排序

折半插入排序是對插入排序的改進，又稱二分插入排序，折半插入排序也是穩定的。

在傳統插入排序中，在將一個數插入到已排序陣列中時，要逐一比較。我們可以採用折半查詢的方法尋找要插入的位置，這樣可以減少比較次數。示例如下：

public static void binaryInsertSort(int[] array) {
    Instant begin = Instant.now();
    for (int i = 1; i < array.length; i++) {
        int t = array[i];
        int low = 0, high = i - 1;
        while (low <= high) {
            int pivot = (low + high) >> 1;
            if (t < array[pivot])
                high = pivot - 1;
            else
                low = pivot + 1;
        }
        for (int j = i; j > low; j--) {
            array[j] = array[j - 1];
        }
        array[low] = t;
    }
    Instant end = Instant.now();
    System.out.println(Duration.between(begin, end));
}

快速排序（quick sort）

快速排序運用了分治思想：要解決規模為n的問題，可以遞迴地解決兩個規模近似為 n/2 的子問題，然後對他們的答案進行合併以得到整個問題的答案。分治法是很多高效演算法的基礎，如排序演算法（快速排序、歸併排序）、傅立葉變換（快速傅立葉變換）。

快速排序於1962年被提出，快速排序的執行時間取決於劃分是否平衡。平均情況下快速排序的時間複雜度為 O(NlogN)。它的排序過程如下：

現有陣列array如下所示：

5 8 3 7 4 1 6 2

對陣列進行排序（升序），首先要選擇一個基準數，小於等於基準數的放到左邊，大於基準數的放到右邊。一般選陣列的第一個數作為基準數。在這裡將m = array[0]作為基準數。

剩下的七個數要進行"站邊"。這裡有兩種處理方式，一種是從左往右掃描陣列（單向劃分），一種是兩邊依次進行掃描（雙向劃分）。雙向劃分的效能更好，因此這裡只討論雙向劃分。

那應該從左邊開始掃描還是從右邊開始掃描呢？答案是最好從右邊開始。

因為我們將array[0]的元素拿出來賦給了一個變數，相當於第一個元素的位置空了下來，這時候需要從右半部分選一個小於等於基準數的放到這個位置。如果從左邊開始的話也能實現，但沒有從右邊開始直觀、易於實現。

示意圖如下：

5
2 8 3 7 4 1 6
接下來從左邊開始掃描，將大於基準數的放到右邊的空位上。示意圖如下：
5
2 3 7 4 1 6 8
一直迴圈進行，直到左右兩邊迴圈“相遇”。迴圈結束後應該是這個樣子：
5
2 1 3 4 7 6 8
下面將基準數放到空位即完成了本輪迴圈，接下來對m的左邊和右邊遞迴進行這個過程，直到只有一個元素，完成排序。

完整的Java程式碼如下：

public static void quickSort(int[] array, int left, int right) {
    if (left < right) {
        int m = array[left];
        int i = left, j = right;
        while (i < j) {
            while (i < j) {
                if (array[j] < m) {
                    array[i++] = array[j];
                    break;
                }
                j--;
            }
            while (i < j) {
                if (array[i] > m) {
                    array[j--] = array[i];
                    break;
                }
                i++;
            }
        }
        array[i] = m;
        quickSort(array, left, i - 1);
        quickSort(array, i + 1, right);
    }
}

經過測試，對一個長度為一百萬的隨機int陣列排序，需要0.2s左右，相比插入排序效率提升很多。

注意，當快速排序的輸入是一個有序序列的時候，快速排序會退化成氣泡排序，它的時間複雜度為O（n2）。每次劃分實際上只減少了一個元素，此時的最大遞迴深度為N，也就是陣列的長度。此時如果對較大型的陣列進行排序，可能會出現StackOverflowError（取決於JVM棧的大小）。

解決方法是在每次選擇基準數的時候採用隨機選擇的方法而不是固定選擇第一個。

示例如下：

public static void quickSort(int[] array, int left, int right) {
    if (left < right) {
        Random random = new Random();
        int n = random.nextInt(right - left + 1) + left;
        int m = array[n];
        array[n] = array[left];
        array[left] = m;
        int i = left, j = right;
        while (i < j) {
            while (i < j) {
                if (array[j] < m) {
                    array[i++] = array[j];
                    break;
                }
                j--;
            }
            while (i < j) {
                if (array[i] > m) {
                    array[j--] = array[i];
                    break;
                }
                i++;
            }
        }
        array[i] = m;
        quickSort(array, left, i - 1);
        quickSort(array, i + 1, right);
    }
}

這樣當輸入是一個有序序列時，仍能保持較快的排序速度，而不會丟擲StackOverflowError。

從實現過程可知，快速排序不是穩定的。

歸併排序（merge sort）

歸併排序與快速排序一樣都採用了分治思想，它將待排序序列分為若干個子序列，每個子序列是有序的，然後再把有序子序列合併為整體有序序列。

若將兩個有序表合併成一個有序表，稱為二路歸併。

歸併排序的時間複雜度與快速排序一樣都為 O(NlogN)，但歸併排序是穩定的，這在有些情況下是很重要的。歸併排序的空間複雜度是 O(n)，可以看到歸併排序相比其它排序演算法所需的空間更多，但帶來的是時間效率的提升。

假設現在有一個數組a，其中有10個元素。

  1. 第一次分割，得到兩個子陣列，分別為a[0]-a[4]，a[5]-a[9]
  2. 對左半部分繼續分割，得到兩個子陣列，分別為a[0]-a[2]，a[3]-a[4]
  3. 對左半部分繼續分割，得到兩個子陣列，分別為a[0]-a[1]，a[2]
  4. 對左半部分繼續分割，得到兩個子陣列，分別為a[0]，a[1]
  5. 兩個子陣列都只有一個元素，不需再分，對這兩個子陣列排序，將結果存在一個臨時陣列中
  6. 返回到3繼續執行下面的程式碼
  7. ......

實現歸併排序有兩種方式，遞迴法實現與迭代法實現。

遞迴法實現如下：

public static void mergeSort(int[] arr) {
    int[] temp = new int[arr.length];
    mergeSortByRecursive(arr, temp, 0, arr.length - 1);
}

private static void mergeSortByRecursive(int[] arr, int[] temp, int start, int end) {
    if (start >= end)
        return;
    int middle = ((end - start) >> 1) + start;
    int start1 = start, start2 = middle + 1;
    //左半部分排序
    mergeSortByRecursive(arr, temp, start1, middle);
    //右半部分排序
    mergeSortByRecursive(arr, temp, start2, end);
    //左右兩部分合並
    int k = start;
    while (start1 <= middle && start2 <= end)
        temp[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= middle)
        temp[k++] = arr[start1++];
    while (start2 <= end)
        temp[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = temp[k];
}

雖然網上有很多現成的例子，還是建議大家自己動手敲一下，加深理解。只有自己動手去做過才會發現許多意想不到的錯誤，比如移位運算：

int middle = 2 >> 1 + 3;

結果是0而不是4，因為 >> 的優先順序低於 +。

迭代法的實現可以參考維基百科，相比遞迴，迭代法顯得不是很直觀。

注：維基百科Java迭代版說原版程式碼的迭代次數少了一次，沒有考慮到奇數列陣列的情況，因此block的上限是陣列長度的兩倍，但block的上限是陣列的長度就可以了。

Java中的排序函式

Arrays.sort()：

  • 對於基本型別陣列，如果陣列長度大於等於286且連續性好，歸併排序；如果長度大於等於286且連續性不好，快速排序；如果長度小於286且大於等於47，快速排序；如果長度小於47，插入排序
  • 對於物件型別陣列，使用TimSort排序。Timsort結合了歸併排序和插入排序，對各種情況都有比較好的效率，而且是穩定性排序。簡單來說，當陣列長度小於32，二分插入排序；大於32，優化的歸併排序
Collections.sort()：呼叫Arrays.sort()的TimSort排序

相關推薦

經典排序演算法 — java 實現

排序演算法的好壞對於效率的影響十分顯著。好的排序演算法排序100萬個整數可能只需要一秒（不考慮硬體因素），不好的排序演算法可能需要一個小時甚至幾個小時。 常見的排序演算法有氣泡排序、插入排序、堆排序、快速排序等，這些排序都屬於基於比較的排序，因此這些演算法的時間

十大經典排序演算法(Java實現)

import java.util.ArrayList; import java.util.Arrays; /** * @author lollipop * @email [email protected] * @date 2018/11/22 0022 8:36 *

十大經典排序演算法Java實現

import java.time.Duration; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.Arrays; public class Sort {

7種經典排序演算法Java程式碼實現(冒泡+選擇+插入+歸併+快排+堆排序+希爾)

氣泡排序 氣泡排序的原理是：比較兩個相鄰的元素，將值較大的元素交換到至右端（比較+移動） public static void sortMpao(int[] num) {     for(int i = 1; i < num.length; i++) {

基本排序演算法-java實現

最近重新學習了排序演算法，之前每次看完當時理解了，但是過一段時間就又忘了，尤其是程式碼，如果放一段時間有很多base case不知道怎麼寫了，所以還是應該詳細的解讀一下再不斷了敲程式碼才能理解比較深刻。 1.氣泡排序（bubble sort） 氣泡排序是一種簡單的排序演算法。其基本思

氣泡排序演算法java實現

package algorithm; /** * 氣泡排序演算法 * @author su * */ public class BubbleSort { public static void main(String[] args) { int[] a = {6,2,5,4,7,1,

經典排序演算法的實現（選擇，插入，shell，堆，快速，歸併排序）

1.選擇排序 //選擇排序 void selectSort(int * arr, int n) { for (int i = 0; i < n - 1; i++) { int min = arr[i]; int minPos = i; for (int j = i

6種排序演算法java實現

6種排序演算法 氣泡排序 選擇排序 插入排序 計數排序 快速排序 歸併排序 1）氣泡排序       相鄰的兩個數字比較排序，先將最大的交換到最後面，然後重複。 程式碼實現 2）選擇排序       從第一個位置開始，用某個位置依次與後邊所有元

連結串列排序演算法java實現（連結串列的快速排序、插入排序、歸併排序）

難易程度：★★ 重要性：★★★      連結串列的排序相對陣列的排序更為複雜些，也是考察求職者是否真正理解了排序演算法（而不是“死記硬背”） 連結串列的插入排序 public class LinkedInsertSort { static cla

常見排序演算法Java實現

目前最經典的排序演算法要屬：氣泡排序，快速排序，簡單插入排序，希爾排序，簡單選擇排序，堆排序，二路歸併排序，多路鬼 並排序，計數排序，桶排序，基數排序。以下就是這些常見演算法的Java實現，有興趣的可以自行實現。現在我們就來一個個分析 介紹一下各自的基礎思想和實現。講解這些演

八種排序演算法Java實現-希爾排序

/*********希爾排序先從0定義再到gap*********************/ public static int[] shell2(int []num,int len){

分治歸併排序演算法——Java實現

1、分治法     許多有用的演算法在結構上是遞迴的：為了解決一個給定的問題，演算法一次或多次遞迴地呼叫其自身以解決緊密相關的若干子問題。這些演算法典型地遵循分治法的思想：將原問題分解為幾個規模較小但類似於原問題的子問題，遞迴地求解這些子問題，然後再合併這些子問題的解來建立

排序演算法Java實現——歸併排序

歸併排序（也可以叫合併排序），其實歸併排序的本質就是合併排序。 它是與插入排序、交換排序、選擇排序不同的一類排序方法，不同之處在於： 它要求：待排序序列是由若干個有序子序列組成。 那麼究竟什麼是歸併排序呢？歸併這個詞到底是什麼意思？ 首先可以理解為就是合併，然後就是這個詞的

簡單選擇排序演算法JAVA實現

簡單選擇排序的過程為：第1次，從n個記錄中找出關鍵碼最小的記錄與第1個記錄交換，第2次，，從第2個記錄開始的n-1個記錄中再選出關鍵碼最小的記錄與第2個記錄交換；如此，第i次，則從第i個記錄開始的n-i+1個記錄中選出關鍵碼最小的記錄與第i個記錄交換，直到整個序列按關鍵碼有序。 例：3，1，4，

氣泡排序演算法 Java 實現過程及詳解

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

深度剖析八大經典排序演算法—C++實現（通俗易懂版）

內容會持續更新，有錯誤的地方歡迎指正，謝謝! 引言 需握各種排序和常用的資料結構的核心思想，並知道是以什麼樣的方式解決了什麼樣的問題。 該部落格的示例程式碼均以遞增排序為目的~ 學習建議：切忌看示例程式碼去理解演算法，而是理解演算法原理寫出程式碼，否

八種排序演算法-Java實現

1.選擇排序 基本思想：在要排序的一組數中，選出最小的一個數與第一個位置的數交換；然後在剩下的數當中再找最小的與第二個位置的數交換，如此迴圈到倒數第二個數和最後一個數比較為止。 程式碼實現 p

排序演算法Java實現——桶排序

桶排序： 一、條件 桶排序不在是一種基於比較的排序方法，而是需要待排序列滿足以下兩個條件： 1）待排序列的值處於一個可列舉的範圍內 2）待排序列所在可列舉範圍不應太大，不然開銷會很大。 二、場景

幾種排序演算法java實現

沒有配圖，過幾天補上 package com.sort; public class Sort { /** * 插入排序 * 原理：往有序的子陣列選擇一個合適的位置插進去 * */ public void insertSort(int sort[

排序演算法Java實現——選擇排序（直接選擇排序）

比較排序程式碼： /*@(#)chooseSort.java 2017-4-22 * Copy Right 2017 Bank of Communications Co.Ltd. * A