Java排序算法（四）：快速排序

Java排序算法（四）：快速排序

快速排序是一个速度非常快的交换排序算法，它的基本思路很简单，从待排的数据序列中任取一个数据（如第一个数据）作为分界值，所有比它小的数据元素放到左边，所有比它大的数据元素放到它的右边。经过这样一趟下来，该序列形成左右两个子序列，左边序列中的数据元素的值都比分界值小，右边序列中数据元素的值都比分界值大。
接下来对左右两个子序列进行递归排序，对两个子序列重新选择中心元素并依此规则调整，直到每个元素子表的元素只剩下一个元素，排序完成。

思路：
1.定义一个i变量，i变量从左边第一个索引开始，找大于分界值的元素的索引，并用i来记录它。
2.定义一个j变量，j变量从右边第一个索引开始，找小于分界值的元素的索引，并用j来记录它。
3.如果i<j，交换i,j两个索引处的元素。
重复执行以上1,2,3步，直到i>=j，可以判断j左边的数据元素都小于分界值，j右边的数据元素都大于分界值，最后将分界值和j索引处的元素交换即可。

时间复杂度
最好情况（每次总是选到中间值作枢轴）T(n)=O(nlogn)
最坏情况（每次总是选到最小或最大元素作枢轴）
做n-1趟，每趟比较n-i次，总的比较次数最大：[O(n²)]
平均时间复杂度为：：T(n)=O(nlogn)

代码实现：

[java]  view plain copy print ?

1. package sort;  
2.   
3. public class QuickSortTest {  
4.   
5.     public static void main(String[] args) {  
6.         int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  
7.         print(data);  
8.         quickSort(data, 0, data.length - 1);  
9.         System.out.println("排序后的数组：");  
10.         print(data);  
11.     }  
12.   
13.     public static void swap(int[] data, int i, int j) {  
14.         if (i == j) {  
15.             return;  
16.         }  
17.         data[i] = data[i] + data[j];  
18.         data[j] = data[i] - data[j];  
19.         data[i] = data[i] - data[j];  
20.     }  
21.   
22.     public static void quickSort(int[] data, int start, int end) {  
23.         if (start >= end)  
24.             return;  
25.         //以起始索引为分界点  
26.         int pivot = data[start];  
27.         int i = start + 1;  
28.         int j = end;  
29.         while (true) {  
30.             while (i <= end && data[i] < pivot) {  
31.                 i++;  
32.             }  
33.             while (j > start && data[j] > pivot) {  
34.                 j--;  
35.             }  
36.             if (i < j) {  
37.                 swap(data, i, j);  
38.             } else {  
39.                 break;  
40.             }  
41.         }  
42.         //交换 j和分界点的值  
43.         swap(data, start, j);  
44.         print(data);  
45.         //递归左子序列  
46.         quickSort(data, start, j - 1);  
47.         //递归右子序列  
48.         quickSort(data, j + 1, end);  
49.     }  
50.   
51.     public static void print(int[] data) {  
52.         for (int i = 0; i < data.length; i++) {  
53.             System.out.print(data[i] + "\t");  
54.         }  
55.         System.out.println();  
56.     }  
57.   
58. }  

运行结果：

[java]  view plain copy print ?

1. 5   3   6   2   1   9   4   8   7     
2. 1   3   4   2   5   9   6   8   7     
3. 1   3   4   2   5   9   6   8   7     
4. 1   2   3   4   5   9   6   8   7     
5. 1   2   3   4   5   7   6   8   9     
6. 1   2   3   4   5   6   7   8   9     
7. 排序后的数组：  
8. 1   2   3   4   5   6   7   8   9