排序原理：

1.首先設定一個分界值，通過該分界值將陣列分成左右兩部分；

2.將大於或等於分界值的資料放到到陣列右邊，小於分界值的資料放到陣列的左邊。此時左邊部分中各元素都小於或等於分界值，而右邊部分中各元素都大於或等於分界值；

3.然後，左邊和右邊的資料可以獨立排序。對於左側的陣列資料，又可以取一個分界值，將該部分資料分成左右兩部分，同樣在左邊放置較小值，右邊放置較大值。右側的陣列資料也可以做類似處理。

4.重複上述過程，可以看出，這是一個遞迴定義。通過遞迴將左側部分排好序後，再遞迴排好右側部分的順序。當左側和右側兩個部分的資料排完序後，整個陣列的排序也就完成了。

排序過程:

例::{6, 1, 2, 7, 9, 3, 4, 5, 8}

切分原理：

把一個數組切分成兩個子陣列的基本思想：

1.找一個基準值，用兩個指標分別指向陣列的頭部和尾部；

2.先從尾部向頭部開始搜尋一個比基準值小的元素，搜尋到即停止，並記錄指標的位置；

3.再從頭部向尾部開始搜尋一個比基準值大的元素，搜尋到即停止，並記錄指標的位置；

4.交換當前左邊指標位置和右邊指標位置的元素；

5.重複2,3,4步驟，直到左邊指標的值大於右邊指標的值停止。

package com.sort;
/*--------------
 *  Author:Real_Q
 *  Date:2021-01-09
 *  Time:11:53
 *  Description:快速排序
---------------*/
public class QuickSort {
    //定義排序函式
    public static void quickSort(int[] array) {
        int low = 0;
        int high = array.length - 1;
        quickSort(array, low, high);
    }

    //過載排序函式
    public static void quickSort(int[] array, int low, int high) {
        if (low >= high) {
            return;
        }
        int index = partition(array, low, high);
        quickSort(array, low, index - 1);
        quickSort(array, index + 1, high);
    }

    //核心函式 獲取基準值的索引並且返回(基準值從首元素開始找,找到合適的為返回索引)
    public static int partition(int[] array, int low, int high) {
        //基準值
        int key = array[low];
        //指向尾部
        int left = low;
        //指向頭部
        int right = high + 1;
        while (true) {
            //2.先從尾部向頭部開始搜尋一個比基準值小的元素，搜尋到即停止，並記錄指標的位置；
            while (less(key, array[--right])) {
                if (right <= low) {
                    break;
                }
            }
            //3.再從頭部向尾部開始搜尋一個比基準值大的元素，搜尋到即停止，並記錄指標的位置；
            while (less(array[++left], key)) {
                if (left >= high) {
                    break;
                }
            }
            //4.交換當前左邊指標位置和右邊指標位置的元素；
            if (left >= right) {//left和right相遇,left == right,遍歷完了 跳出迴圈
                break;
            } else {//符合條件 交換eft和right索引值
                exchange(array, left, right);
            }
        }

        //把key與right處的索引值交換,並且返回索引
        exchange(array, low, right);
        return right;
    }

    //比較兩個元素的大小,返回比較結果
    public static boolean less(int a, int b) {
        return ((a - b) < 0);
    }

    //交換陣列中的兩個元素
    public static void exchange(int[] array, int index1, int index2) {
        int temp;
        temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }
}

 

測試類:

package com.testsort;
import java.util.Arrays;
import static com.sort.QuickSort.quickSort;
/*--------------
 *  Author:Real_Q
 *  Date:2021-01-09
 *  Time:14:36
 *  Description:
---------------*/
public class TestQuick {
    public static void main(String[] args) {
        //int[] array = {8,4,5,7,1,3,6,2};
        int[] array = {6, 1, 2, 7, 9, 3, 4, 5, 8};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }
}