快速排序 ｊａｖａ

一直想复习下算法,先把经典的快排复习下,好好理解下分治思想:

先介绍快速排序的算法过程:

[1].记录第一个数位置和最后一个数位置; int i = low; int j = high;
[2].找到主元位置,可以是第一个数,也可以是最后一个,或者随机的一个位置,一般可以以数组中第一个位置的数,
    int povit = a[low],主元选择好了就记录不改变它的值;
[3].如果主元是第一个数,则由 j 从后向前搜索,直到找到第一个小于主元的数,与主元进行交换位置.
[4].然后由 i 从前向后搜索,找到第一个大于主元的数,并与主元交换位置.

[5].重复[3],[4]步骤,直到 i = j;

a[0] ..........a[7]
12,3,5,44,21,8,56,2


主元:a[0] = 12;
-----------------------------------------------------------------
2,3,5,44,21,8,56,12    i = 1; j = 7;

2,3,5,12,21,8,56,44    i = 3;j  =6;
---------------------- 一趟完成,开始第二趟------------------------
2,3,5,8,21,12,56,44    i = 4;j = 5;

2,3,5,8,12,21,56,44    i = 4;j = 4;
---------------------- 一趟完整移位结束,主元移到了 4 的位置------------------------

----------------------此时由主元位置分为前后2个数组-------------------------------
{2,3,5,8} 12 {21,56,44}
----------------------递归对前后2个数组进行上述移位操作---------------------------

而在最坏情况下，即数组已经有序或大致有序的情况下，每次划分只能减少一个元素，快速排序将不幸退化为冒泡排序，所以快速排序时间复杂度下界为O(nlogn)，最坏情况为O(n^2)。在实际应用中，快速排序的平均时间复杂度为O(nlogn)。

[java] view plaincopyprint?

1. package test;  
2.   
3. import java.util.Date;  
4. import java.util.Iterator;  
5. import java.util.Properties;  
6.   
7. public class test {  
8.     public static void main(String args[])  
9.     {  
10.         test t = new test();  
11.           
12.         Comparable a[] = {12,3,5,44,21,8,56,2};  
13.         t.quickSort(a, 0, a.length-1);  
14.           
15.         for(Comparable c : a)  
16.         {  
17.             System.out.print(c.toString()+",");  
18.         }  
19.     }  
20.       
21.     public void quickSort(Comparable a[],int low,int high)  
22.     {  
23.         if(low < high)  
24.         {  
25.             int i = partition(a,low,high);  
26.             //再递归移位i前面一个数组   
27.             quickSort(a, low,i-1);  
28.             //再递归移位i后面一个数组   
29.             quickSort(a, i+1, high);  
30.         }  
31.     }  
32.   
33.     public int partition(Comparable a[],int low,int high)  
34.     {  
35.             int i = low;  
36.             int j = high;  
37.               
38.             //主元   
39.             Comparable pivot = a[low];  
40.               
41.             if(low<high)  
42.            {  
43.                 while(i != j)  
44.                 {  
45.                     printA(a);  
46.                     //从j开始往前扫描直到第一个小于主元的数字出现,与主元交换  
47.                     while(i < j)  
48.                     {  
49.                         if(a[j].compareTo(pivot) < 0)  
50.                         {  
51.                             swap(a, j,i);  
52.                             break;  
53.                         }  
54.                         j--;  
55.                     }  
56.                     if(i < j)  
57.                     {  
58.                         //此时,因为与i互换了位置,i需要向后移动一位  
59.                         i++;  
60.                     }  
61.                       
62.                     //从i开始往后扫描,直到第一个大于主元的数字出现,与主元交换  
63.                     while(i<j)  
64.                     {  
65.                         if(a[i].compareTo(pivot) > 0)  
66.                         {  
67.                             swap(a,i,j);  
68.                             break;  
69.                         }  
70.                         i++;  
71.                     }  
72.                       
73.                     if(i<j)  
74.                     {  
75.                         //此时,因为与j互换了位置,j需要向前移动一位  
76.                         j--;  
77.                     }  
78.                       
79.                     printA(a);  
80.                 }  
81.            }  
82.             return i;     
83.     }  
84.       
85.     public int partition2(Comparable a[],int l, int r)  
86.     {  
87.         int i = l, j = r;  
88.         Comparable x = a[l]; //s[l]即s[i]就是第一个坑  
89.         while (i < j)  
90.         {  
91.             // 从右向左找小于x的数来填s[i]  
92.             while(i < j && a[j].compareTo(x) >= 0)   
93.                 j--;    
94.             if(i < j)   
95.             {  
96.                 a[i] = a[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑  
97.                 i++;  
98.             }  
99.   
100.             // 从左向右找大于或等于x的数来填s[j]   
101.             while(i < j && a[i].compareTo(x) < 0)  
102.                 i++;    
103.             if(i < j)   
104.             {  
105.                 a[j] = a[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑  
106.                 j--;  
107.             }  
108.         }  
109.         //退出时，i等于j。将x填到这个坑中。   
110.         a[i] = x;  
111.   
112.         return i;  
113.     }  
114.       
115.     public void swap(Comparable a[],int i, int j)  
116.     {  
117.         Comparable temp = a[i];  
118.         a[i] = a[j];  
119.         a[j] = temp;  
120.     }  
121.   
122.     public void printA(Comparable a[])  
123.     {  
124.         for(Comparable c : a)  
125.         {  
126.             System.out.print(c.toString()+",");  
127.         }  
128.         System.out.println();  
129.     }  
130. }