快速排序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] 小于基准值，和基准值交换是没有问题的。

　　以上就是我对这个问题的一点思考了。