快速排序java實現

1.快速排序的思想

　　快速排序屬於交換排序，是冒泡排序的升降版。相對於冒泡排序而言，快速排序增大了記錄比較和移動的距離，將關鍵字較大的記錄直接移動到後面，將關鍵字較小的記錄直接移動到前面；再也不是相鄰兩個記錄依次進行比較和交換，須要屢次移動才能將關鍵字較大的記錄移動到後面。從而快速排序減小了總的比較次數和移動次數。

　　快速排序是指，在待排序記錄中選擇一個記錄做爲基準記錄(一般選擇第一個)，從待排序兩端開始交替比較，使得基準記錄左側的記錄的關鍵字都比基準記錄的關鍵字小，右側都比基準記錄大，這就是一趟快排。再將基準記錄分出來的兩個區域進行快排，以此類推，直到每一個分區只有一個元素。

　　快速排序採用的分冶法的策略。

2.快速排序的本質

　　快速排序本質是不斷肯定所選基準值的位置，當分區中只有一個記錄時，不須要進行移動，排序結束。網上有一張圖展現的很到位：(侵刪）

3.代碼

 1 public class QuickSort {
 2     public int[] quickSort(int[] data, int start, int end){
 3         if(start > end) return null;
 4         int pivot = data[start]; // 基準值
 5         int i = start;
 6         int j = end;
 7         int tmp;
 8         while(i < j){
 9             while(i<j && data[i] <= pivot){
10                 i++;
11             }
12             while(j>=i && data[j] >= pivot){ //注意這裏j>=i
13                 j--;
14             }
15             if(i < j){
16                 tmp = data[i];
17                 data[i] = data[j];
18                 data[j] = tmp;
19             }
20         }
21         if(j > start){
22             tmp = data[start];
23             data[start] = data[j];
24             data[j] = tmp;
25         }
26         quickSort(data,start,j-1);
27         quickSort(data,j+1,end);
28         return data;
29     }
30 
31     public static void main(String[] args){
32         QuickSort sort = new QuickSort();
33         int[] data = {70,30,40,10,80,20,90,100,75,60,45};
34         data = sort.quickSort(data,0,data.length-1);
35         for(int x : data) {
36             System.out.println("quickSort" + x);
37         }
38     }
39 }

4.須要注意的地方

快排有多種實現方法，在一些資料上提到：每一趟排序必須右端先走，而後左端再走。這樣操做的緣由是來自於代碼的寫法，他們的代碼寫法以下：

 

 

 

 

 1 package learn;
 2 //快速排序
 3 public class QuickSort {
 4     public int[] quickSort(int[] data, int start, int end){
 5         if(start > end) return null;
 6         int pivot = data[start]; // 基準值
 7         int i = start;
 8         int j = end;
 9         int tmp;
10         while(i < j){
11 //            while(i<j && data[i] <= pivot){
12 //                i++;
13 //            }
14 //            while(j>=i && data[j] >= pivot){ //注意這裏j>=i
15 //                j--;
16 //            }
17             while(j>i && data[j] >= pivot){
18                 j--;
19             }
20             while(i<j && data[i] <= pivot){
21                 i++;
22             }
23             if(i < j){
24                 tmp = data[i];
25                 data[i] = data[j];
26                 data[j] = tmp;
27             }
28         }
29         if(j > start){ //當j = start避免一趟排序，這個約束條件不是必須的
30             tmp = data[start];
31             data[start] = data[j];
32             data[j] = tmp;
33         }
34         quickSort(data,start,j-1);
35         quickSort(data,j+1,end);
36         return data;
37     }
38 
39     public static void main(String[] args){
40         QuickSort sort = new QuickSort();
41         int[] data = {70,30,40,10,80,20,90,100,75,60,45};
42         data = sort.quickSort(data,0,data.length-1);
43         for(int x : data) {
44             System.out.println("quickSort" + x);
45         }
46     }
47 }

　　區別在於第11-16行和第17-22行。按照17-22行，j 結束的條件是 j>i，咱們考慮一下while( i < j)結束後 i == j，若是讓i 先出發，i 停在值大於基準值的位置；由於 j>i 條件的約束，j只能也停留在i處，這個時候在while( i < j)結束後交換data[j] ，(data[j] == data[i])，就把大於基準值的data[j]交換到基準值左邊了。但按照17-22行，讓j先出發，總會停在小於基準值的位置，這樣循環結束後和基準值交換是沒有問題的。

　　或者按照11-16行的寫法，誰先出發無所謂，只要j 結束的條件變成 j >= i，那麼 j 會跑到 i 停下來的前一個位置再停下來，這時data[j] 小於基準值，和基準值交換是沒有問題的。

　　以上就是我對這個問題的一點思考了。