快速排序

快速排序法介绍

快速排序（Quicksort）是对冒泡排序的一种改进。

基本思想是：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

快速排序法示意图:

 

 

 

 代码实现

1. public class quicksort {  
2.     public static void main(String[] args) {  
3.         int[] arr = {-1, 7, 1, 7, 14, -3, 7};  
4.         System.out.println("原数组为：" + Arrays.toString(arr));  
5.         quickSort(arr, 0, arr.length - 1);  
6.         System.out.println("排序后数组为：" + Arrays.toString(arr));  
7.     }  
8.   
9.     private static void quickSort(int[] arr, int left, int right) {  
10.           
11.         if (left < right) {//当left>=right说明当前数组已经是完全有序的了  
12.               
13.             int l = left;//左指针指向（当前的）数组第一个元素  
14.             int r = right - 1;//右指针指向（当前）数组最后一个的前一个元素  
15.             int pivot = arr[right];//定义中轴值为数组的最后一个元素  
16.             int temp = 0;//临时变量，作为交换时使用  
17.   
18.             while (true) {  
19.                 /** 
20.                  * 说明： 
21.                  * l < right保证l不会超出当前数组 
22.                  * arr[l] <= pivot中的等号不要忘了，否则遇到与中轴值相等的元素，就会发生死循环！！ 
23.                  */  
24.                 while (l < right && arr[l] <= pivot) {  
25.                     l++;  
26.                 }  
27.                 /** 
28.                  * 说明： 
29.                  * r > -1保证l不会超出当前数组 
30.                  * arr[r] >= pivot中的等号不要忘了，否则遇到与中轴值相等的元素，就会发生死循环！！ 
31.                  */  
32.                 while (r > -1 && arr[r] >= pivot) {  
33.                     r--;  
34.                 }  
35.                   
36.                 //通过上面的两个while我们可以找到满足条件的arr[l]和arr[r]  
37.                 // 但是l<r或者l>=r  
38.                 if (l < r) {  
39.                     temp = arr[l];  
40.                     arr[l] = arr[r];  
41.                     arr[r] = temp;  
42.                 } else {//如果 l >= r 说明 pivot 前的数，全部按照顺序排列  
43.                     break;  
44.                 }  
45.             }  
46.   
47.             //跳出while最后还要将pivot与arr[l]交换  
48.             temp = arr[l];  
49.             arr[l] = arr[right];  
50.             arr[right] = temp;  
51.   
52.               
53.             quickSort(arr, left, l - 1);//向左递归 （此时l处元素已经是原来的pivot）  
54.             quickSort(arr, l + 1, right);//向右递归 （此时l处元素已经是原来的pivot）  
55.         }  
56.     }  
57.   
58. }