快速排序(Quicksort)

1. 基本思想：（分治）

   • 先從數列中取出一個數作為key值；
   • 將比這個數小的數全部放在它的左邊，大於或等於它的數全部放在它的右邊；
   • 對左右兩個小數列重複第二步，直至各區間只有1個數。

2. 輔助理解：挖坑填數

   • 初始時 i = 0; j = 9; key=72
     由於已經將a[0]中的數儲存到key中，可以理解成在陣列a[0]上挖了個坑，可以將其它資料填充到這來。
     從j開始向前找一個比key小的數。當j=8，符合條件，a[0] = a[8] ; i++ ; 將a[8]挖出再填到上一個坑a[0]中。
     這樣一個坑a[0]就被搞定了，但又形成了一個新坑a[8]，這怎麼辦了？簡單，再找數字來填a[8]這個坑。
     這次從i開始向後找一個大於key的數，當i=3，符合條件，a[8] = a[3] ; j-- ;
     將a[3]挖出再填到上一個坑中。

     陣列：72 - 6 - 57 - 88 - 60 - 42 - 83 - 73 - 48 - 85
      0   1   2    3    4    5    6    7    8    9

   • 此時 i = 3; j = 7; key=72
     再重複上面的步驟，先從後向前找，再從前向後找。
     從j開始向前找，當j=5，符合條件，將a[5]挖出填到上一個坑中，a[3] = a[5]; i++;
     從i開始向後找，當i=5時，由於i==j退出。
     此時，i = j = 5，而a[5]剛好又是上次挖的坑，因此將key填入a[5]。

     陣列：48 - 6 - 57 - 88 - 60 - 42 - 83 - 73 - 88 - 85
      0   1   2    3    4    5    6    7    8    9
   • 可以看出a[5]前面的數字都小於它，a[5]後面的數字都大於它。因此再對a[0…4]和a[6…9]這二個子區間重複上述步驟就可以了。

     <陣列：48 - 6 - 57 - 42 - 60 - 72 - 83 - 73 - 88 - 85
      0   1   2    3    4    5    6    7    8    9

3. 平均時間複雜度：O(N*logN)

4. 實現（java):

public static void sort(int[] a,int low,int high){
        int start = low;
        int end = high;
        int key = a[low];
        
        
        while(end>start){
            //從後往前比較
            while(end>start&&a[end]>=key)  //如果沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，然後又從前往後比較
                end--;
            if(a[end]<=key){
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //從前往後比較
            while(end>start&&a[start]<=key)//如果沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置
               start++;
            if(a[start]>=key){
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
        //此時第一次迴圈比較結束，關鍵值的位置已經確定了。左邊的值都比關鍵值小，右邊的值都比關鍵值大，但是兩邊的順序還有可能是不一樣的，進行下面的遞迴呼叫
        }
        //遞迴
        if(start>low) sort(a,low,start-1);//左邊序列。第一個索引位置到關鍵值索引-1
        if(end<high) sort(a,end+1,high);//右邊序列。從關鍵值索引+1到最後一個
    }
    
 

key值的選取可以有多種形式，例如中間數或者隨機數，分別會對演算法的複雜度產生不同的影響。