用JAVA代碼實現快速排序

快速排序是對冒泡排序的一種改進。它和堆排法、希爾法一樣效率較高，但穩定性稍差。 
對於小的數組，常用的排序方法效率相差不大，但對於大的數組，用以上的方法進行排序對有好的效率。 
最壞情況的時間複雜度爲O(n^2)，最好情況時間複雜度爲O(nlogn)。 

它的基本思想是： 
1、通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小 
2、然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。 
另外 java沒指針概念 可以認爲是句柄 
假設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個數據）作爲關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱爲一躺快速排序。一趟快速排序的算法是： 
  1）設置兩個變量I、J，排序開始的時候I：=0，J：=N； 
  2）以第一個數組元素作爲關鍵數據，賦值給X，即X：=A[0]； 
  3）從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換； 
  4）從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換； 
  5）重複第3、4步，直到I=J；

例如：升序（前小後大）

待排序的數組A的值分別是：（初始關鍵數據X：=49(將數組分爲兩部分之前，x值不變)） 
                  A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
                  49       38      65      97      76      13       27 
開始：x = 49; 
i = 0;從前往後搜索用變量i 
n = 7;數組長度 
j = n;從後往返前搜索用變量J 

1、進行如上所說的第三步：由後向前搜索   j= j-1=6,也就是用x=49與A[6]比較， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
49       38      65      97      76      13       27 
 X                                               j=j-1=6 
x大於A[6]，交換位置 
進行第一次交換後：  27       38      65      97      76      13       49 

2、進行如上所說的第四步：由前向後搜索  i=i+1=1,也就是用x=49與A[1]比較， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6] 
27       38      65      97      76      13       49 
        i=i+1                                      x 
A[1]大於x,所以不變，所以繼續由前向後搜索 i= i+1=2,也就是x=49與A[2]比較， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6] 
27       38      65      97      76      13       49 
i=i+1                                     x 
A[2]大於x，交換位置 
進行第二次交換後：  27       38      49      97      76      13       65 

3、進行如上所說的第三步：由後向前搜索   j= j-1=5,也就是用x=49與A[5]比較， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
27       38      49      97      76      13       65 
                 X                       j=j-1=5 
x大於A[5]，交換 
進行第三次交換後：  27       38      13      97      76      49       65 

4、進行如上所說的第四步：由前向後搜索i=i+1=3,也就是用x=49與A[3]比較， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
27       38      13      97      76      49       65 
                        i=i+1=3           x 
A[5]>x,交換 
進行第四次交換後：  27       38      13      49      76      97       65 

5、之後，i=j=4 
此時再執行第三步的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是： 
27       38      13      49      76      97       65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。 
        快速排序就是遞歸調用此過程——在以49爲中點分割這個數據序列，分別對前面一部分和後面一部分進行類似 
的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述
數組A的快速排序的全過程如下所示： 
初始狀態                       【49    38    65    97    76    13    27】   
進行一次快速排序之後劃分爲       【27    38    13】   49   【76    97    65】 
分別對前後兩部分進行快速排序     【13】   27   【38】 
                             【65】   76   【97】 
                              結束 

我們下面看看通過JAVA代碼是如何實現的？

public class Sort
{
    public static void main(String[] args)
    {
        int[] arr = { 49, 38, 65, 97, 76, 13, 27 };
        arrayPrint(arr);
        quickSort(arr, 0, arr.length - 1);
        arrayPrint(arr);
    }

    /**
     * 快速排序邏輯部分
     * @param arr
     * @param low
     * @param high
     */
    public static void quickSort(int[] arr , int low , int high)
    {
        int i = low; //相當於i，左 
        int j = high; //相當於j, 右 

        if (i >= j) // 判斷是否到中間了 
            return;

        //確定指針方向的邏輯變量，也就是從左搜索還是向右搜索 
        boolean transfer = true;

        while (i != j)
        {
            if (arr[i] > arr[j])
            {
                //交換數字 
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                //決定下標移動，還是上標移動 
                transfer = (transfer == true) ? false : true;
            }

            //將指針向前或者向後移動 
            if (transfer)
                j--;
            else
                i++;

            //顯示每一次指針移動的數組數字的變化 
            for (int x = 0; x < arr.length; ++x)
            {
                System.out.print(arr[x] + ",");
            }
            System.out.print(" (i,j) = " + "(" + i + "," + j + ")");
            System.out.println("");
        }

        //將數組分開兩半，確定每個數字的正確位置 
        i--;
        j++;
        quickSort(arr, low, i);
        quickSort(arr, high, j);
    }

    /**
     * 打印數組
     * @param arr
     */
    public static void arrayPrint(int[] arr)
    {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++)
        {
            if (i != arr.length - 1)
                System.out.print(arr[i] + ",");
            else
                System.out.println(arr[i] + "]");
        }
    }
}