快速排序算法.

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

假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作爲關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱爲一躺快速排序。一躺快速排序的算法是：

1）、設置兩個變量I、J，排序開始的時候I：=1，J：=N；

2）以第一個數組元素作爲關鍵數據，賦值給X，即X：=A[1]；

3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；

4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；

5）、重複第3、4步，直到I=J；

例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）

A[1]    A[2]    A[3]    A[4]    A[5]     A[6]    A[7]：  

49       38      65      97      76      13       27

進行第一次交換後：  27       38      65      97      76      13       49

( 按照算法的第三步從後面開始找

進行第二次交換後：  27       38      49      97      76      13       65

( 按照算法的第四步從前面開始找>X的值，65>49,兩者交換，此時I：=3 )

進行第三次交換後：  27       38      13      97      76      49       65

( 按照算法的第五步將又一次執行算法的第三步從後開始找

進行第四次交換後：  27       38      13      49      76      97       65

( 按照算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時J：=4 )

此時再執行第三不的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：27       38      13      49      76      97       65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。

快速排序就是遞歸調用此過程——在以49爲中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：

初始狀態                       {49    38    65    97    76    13    27}   

進行一次快速排序之後劃分爲     {27    38    13}    49  {76    97    65}

分別對前後兩部分進行快速排序      27     

結束        結束   {49   65}   76   

49          結束

結束

圖6   快速排序全過程

1）、設有N（假設N=10）個數，存放在S數組中；

2）、在S[1。。N]中任取一個元素作爲比較基準，例如取T=S[1]，起目的就是在定出T應在排序結果中的位置K，這個K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的數都小於S[K]，在S[K]以後的數都大於S[K]；

3）、利用分治思想（即大化小的策略）可進一步對S[1。。K-1]和S[K+1。。N]兩組數據再進行快速排序直到分組對象只有一個數據爲止。

如具體數據如下，那麼第一躺快速排序的過程是：

數組下標： 1     2     3     4     5     6     7     8     9     10

45    36    18    53    72    30    48    93    15     36

I                                                                  J

（1）     36    36    18    53    72    30    48    93    15     45

（2）     36    36    18    45    72    30    48    93    15     53

（3）     36    36    18    15    72    30    48    93    45     53

（4）     36    36    18    15    45    30    48    93    72     53

（5）     36    36    18    15    30    45    48    93    72     53

 通過一躺排序將45放到應該放的位置K，這裏K=6，那麼再對S[1。。5]和S[6。。10]分別進行快速排序

void QuickSort(String[] pData,int[] pDataNum,int left,int right)
...{ 
int i,j; 
int iTemp; 
String middle,strTemp;
i = left; 
j = right; 
middle = pData[(left+right)/2]; 
do...{ 
while((pData[i].compareTo(middle)<0) && (i<right)) 
i++; 
while((pData[j].compareTo(middle))>0 && (j>left)) 
j--; 
if(i<=j) 
...{ 
strTemp = pData[i]; 
pData[i] = pData[j]; 
pData[j] = strTemp; 

iTemp = pDataNum[i]; 
pDataNum[i] = pDataNum[j]; 
pDataNum[j] = iTemp; 

i++; 
j--; 
} 
}while(i<=j);//如果兩邊掃描的下標交錯，就停止（完成一次） 

if(left<j) 
QuickSort(pData,pDataNum,left,j); 

if(right>i) 
QuickSort(pData,pDataNum,i,right); 
} 

2

 

pivotkey把數列分成兩半,然後分別對左右子數列進行冒泡排序,
//排序完後又繼續在子數列劃分子子左數列和子子右數列進行冒泡排序......如始反覆進行遞歸排序
//實際上快速排序是由若干個冒泡排序組合而成.
package sort;
public class Sort2 ...{ 
  public static void main(String args[]) ...{ 
  int vec[] = new int[] ...{ 37, 47, 23, 100, 19, 56, 56, 99, 9};     // 實例化數組
  Sort2 s = new Sort2();                                  // 實例化對象
  s.quicksort(vec, 0, vec.length -1);                // 傳參並調用quicksort
  for (int i=0;i<=vec.length-1;i++) ...{                  // 由小到大輸出
   System.out.println(vec[i]); 
   } 
   }
  public void swap(int a[], int i, int j) ...{              // 通過臨時變量,交換數據
    int tmp = a[i]; 
    a[i] = a[j]; 
    a[j] = tmp; 
  }                                                                  // 第一次交換分析
  public void quicksort(int a[], int low, int high) ...{   // 假設傳入low=0; high=a.length-1;
    if (low < high) ...{                                          // 條件判斷
     int pivot, p_pos, i;                                    // 聲明變量
        p_pos = low;                                         // p_pos指向low,即位索引爲0位置 ;
        pivot = a[p_pos];                                   // 將0位置上的數值賦給pivot;
        for (i = low + 1; i <= high; i++) ...{             // 循環次數, i=1;
         if (a[i]>pivot) ...{                                      // 1位置的數與0位置數作比較: a[1]>a[0]
           p_pos++;                                           // 2位與1位比較,3位與2位比較......
           swap(a, p_pos, i);                              // 傳參並調用swap      
          } 
        } 
      swap(a, low, p_pos);                              // 將p_pos設爲high再次調用swap
      quicksort(a, low, p_pos - 1);                  // 遞歸調用,排序左半區
      quicksort(a, p_pos + 1, high);                // 遞歸調用,排序右半區
    } 
  } 
}