Java之快速排序算法

1、快速排序算法概況

1.首先會選擇第一個元素(實際通常也都會選第一個)做爲比較值（稱「樞軸」（pivot））

2.循環找出小於pivot的元素，將元素放在pivot的左邊

3.循環找出大於pivot的元素，將元素放在pivot的右邊

4.而後再對pivot左邊和右邊的數組進行一樣的操做(遞歸)

2、下面貼上一段代碼：

void quickSort(int[] n) {
        if (n == null || n.length <= 0) {
            return;
        }
        quickSort(n, 0, n.length - 1);
    }

    private void quickSort(int[] n, int low, int high) {//D
        if (low >= high) {
            return;
        }
        int pivot = partition(n, low, high);// A
        quickSort(n, low, pivot - 1);// B
        quickSort(n, pivot + 1, high);// C
    }

    private int partition(int[] n, int low, int high) {
        // 1.定義比較的關鍵值(當前數組第一個位置的元素)
        int pivot = n[low];
        while (low < high) {
            // 2.找到第一個小於關鍵值得數據
            while ((low < high) && (n[high] >= pivot)) {
                high--;
            }
            // 3.找到後將這個小於關鍵值得數據賦值給n[low]
            n[low] = n[high];
            // 4.而後找到第一個大於關鍵值得數據
            while ((low < high) && (n[low] <= pivot)) {
                low++;
            }
            // 5.而後將這個大於關鍵值得數據賦值給n[high]
            n[high] = n[low];
        }
        // 6.循環完畢,返回pivot的位置
        n[low] = pivot;
        return low;
    }

3、分析

假如咱們將傳入int[] n = {20,8,10,12,6}這個數組；

1.進入D，quickSort(int[] n, int low, int high) // low = 0; high = n.length - 1

而後進入A，partition(int[] n, int low, int high) // low = 0; high = n.length - 1

2.首先提取數組的第一個元素做爲pivot，第一個元素pivot固然就是20，以後也都取當前數組的第一個位置的元素做爲pivot；

    int pivot = n[low];

3.判斷low < high，符合進入循環體； while (low < high)

4.判斷找到第一個小於pivot的值；（找到了high下標爲4的元素，a[high]=6）

    while ((low < high) && (n[high] >= pivot)) {

        // 若是沒有找到(對high下標進行遞減操做，直到不知足low < high)

        high--;

    }

5.n[low] = n[high];

    a.若是找到了小於pivot的值，而後將值給n[low]位置，也就是將放在pivot的左邊；

    b.若是沒找到，對high進行遞減操做，直到不知足low < high爲止

    （若是沒找到，high--，最後會是high==low，執行完第6步，因爲不知足循環條件，退出循環），那就是對n[low]自己的值進行操做 這裏找到了(此時high仍是4)，就是將n[4]給了n[0]，

    此刻數組是這樣的：[6,8,10,12,6]

6.判斷找到第一個大於Pivot的值；（這裏面沒有大於20的值，因此會一直對low累加至4，low = 4）;

    // 若是找到了，表示找到了大於pivot的值，若是沒有就將對low自增，直到不知足low < high

    while ((low < high) && (n[low] <= pivot)) {

        low++;

    }

low = 4，這裏，咱們沒有找到比pivot也就是20還要大的值(low經過自增變爲4，high仍是4)，而後將本身賦值給本身。數組此時保持不變：[6,8,10,12,6]

7.此時，不知足low < high退出循環

8.n[low] = pivot; 將pivot值給n[4]。此時數組是這樣的：[6,8,10,12,20]

9.return low; 返回pivot，也就是4。

10.這個時候進入B，而後再執行A

    quickSort(n, low, pivot - 1);

    partition(n, low, pivot - 1)

11.進入遞歸循環調用，步驟和上述同樣。無論第一個步驟是否已經將數組排序好了，快速排序都會執行一遍，直到執行完畢。

最終數組：[6,8,10,12,20]