Java中的經典算法之快速排序(Quick Sort)

快速排序的思想

基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，
然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

假定數組A：46 30 82 90 56 17 95 15，取第一個數46位基數，l=0(l是字母，不是數字1)指向第一個數，h=7指向最后一個數：

從右向左找出第一個小於46的數；先比較A[0]和A[7]:
    46 30  82  90  56  17  95  15
    =》46和15比較=》15  30  82  90  56  17  95  46：交換位置，此時l需要+1變為l=1;h=7
    （如果之前比較沒有找到小於46的數，則繼續取h=6位置的數和46比較，直到取到小於46的數為止）

然后從左向右找出第一個大於46的數:比較A[1]和A[7]:
    15  30  82  90  56  17  95  46
    =》30和46比較=》15  30  82  90  56  17  95  46：未交換位置，繼續取左邊下一個數字，

繼續從左向右找出第一個大於46的數,此時所以l=2;h=7；比較A[2]和A[7]:
    15  30  82  90  56  17  95  46
    =》82和46比較=》15  30 46 90  56  17  95  82：交換位置

此時需要從右向左再找出下一個比46小的數，所以l=2,h=6，比較A[2]和A[6]：
    15  30 46 90  56  17  95  82
    =》46和95比較=》15  30 46 90  56  17  95  82：未交換位置

繼續從左向右找比46小的數字，此時l=2,h=5,比較A[2]和A[5]：
    15  30 46 90  56  17  95  46
    =》46和17比較=》15  30  17  90  56 46 95  82：交換位置

再從左向右找比46大的數字，此時l=3,h=5;比較A[3]和A[5]：
    15  30  17  90  56 46 95  82
    =》90和46比較=》15  30  17 46 56  90  95  82：交換位置

再從右向左找比46小的數字，此時l=3,h=4; 比較A[3]和A[4]：
    15  30  17 46 56  90  95  82
    =》46和56比較=》15  30  17 42 56  90  95  82：為交換位置

繼續從右向左找比46小的數字，此時l=3,h=3,l==h;此時A[3]左邊數字（15,30,17,）全部是小於右邊數字（90,95,82）的；

然后對子序列各自進行如上排序，直到子序列元素個數不大於1為止；

  public static void main(String[] args) {
        int[] a = {46, 30, 82, 90, 56, 17, 95, 15};
        int start = 0;
        int end = a.length - 1;
        sort(a, start, end);
        for (int anA : a) {
            System.out.println(anA);
        }
    }

    public static void sort(int arr[], int low, int high) {
        int l = low;
        int h = high;
        int baseNum = arr[low];

        while (l < h) {
            //1.從右向左查找小於指定基數的數，找到之后跳出循環執行下面if循環，交換數據
            while (l < h && arr[h] >= baseNum) {
                h--;
            }
            //交換數據
            if (l < h) {
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                l++;
            }

            //2.從左向右查找大於指定基數的數，找到后跳出循環執行下面if循環，交換數據
            while (l < h && arr[l] <= baseNum)
                l++;
            //交換數據
            if (l < h) {
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                h--;
            }
        }
        if (l > low) {
            sort(arr, low, l - 1);
        }
        if (h < high) {
            sort(arr, l + 1, high);
        }
    }

輸出結果：

15
17
30
46
56
82
90
95