快速排序算法原理及java递归实现

快速排序 对冒泡排序的一种改进，若初始记录序列按关键字有序或基本有序，蜕化为冒泡排序。使用的是递归原理，在所有同数量级O(n longn) 的排序方法中，其平均性能最好。就平均时间而言，是目前被认为最好的一种内部排序方法
基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
三个指针: 第一个指针称为pivotkey指针（枢轴），第二个指针和第三个指针分别为left指针和right指针，分别指向最左边的值和最右边的值。left指针和right指针从两边同时向中间逼近，在逼近的过程中不停的与枢轴比较，将比枢轴小的元素移到低端，将比枢轴大的元素移到高端，枢轴选定后永远不变，最终在中间，前小后大。

需要两个函数：

① 递归函数  public static void quickSort(int[]n ,int left,int right)
② 分割函数（一趟快速排序函数） public static int partition(int[]n ,int left,int right)

JAVA源代码（成功运行）：

[java]  view plain copy print ?

1. package testSortAlgorithm;  
2.   
3. public class QuickSort {  
4.     public static void main(String[] args) {  
5.         int [] array = {49,38,65,97,76,13,27};  
6.         quickSort(array, 0, array.length - 1);  
7.         for (int i = 0; i < array.length; i++) {  
8.             System.out.println(array[i]);  
9.         }  
10.     }  
11.     /*先按照数组为数据原型写出算法，再写出扩展性算法。数组{49,38,65,97,76,13,27} 
12.      * */  
13.     public static void quickSort(int[]n ,int left,int right){  
14.         int pivot;  
15.         if (left < right) {  
16.             //pivot作为枢轴，较之小的元素在左，较之大的元素在右  
17.             pivot = partition(n, left, right);  
18.             //对左右数组递归调用快速排序，直到顺序完全正确  
19.             quickSort(n, left, pivot - 1);  
20.             quickSort(n, pivot + 1, right);  
21.         }  
22.     }  
23.       
24.     public static int partition(int[]n ,int left,int right){  
25.         int pivotkey = n[left];  
26.         //枢轴选定后永远不变，最终在中间，前小后大  
27.         while (left < right) {  
28.             while (left < right && n[right] >= pivotkey) --right;  
29.             //将比枢轴小的元素移到低端，此时right位相当于空，等待低位比pivotkey大的数补上  
30.             n[left] = n[right];  
31.             while (left < right && n[left] <= pivotkey) ++left;  
32.             //将比枢轴大的元素移到高端，此时left位相当于空，等待高位比pivotkey小的数补上  
33.             n[right] = n[left];  
34.         }  
35.         //当left == right，完成一趟快速排序，此时left位相当于空，等待pivotkey补上  
36.         n[left] = pivotkey;  
37.         return left;  
38.     }  
39. }  

自己理解的写法：

/**
 * 快速排序
 *
 */
public class QickSort {

	 public static void main(String[] args) {  
	        int [] array = {49,38,65,97,76,13,27};  
	        quickSort(array, 0, array.length - 1);  
	        for (int i = 0; i < array.length; i++) {  
	            System.out.println(array[i]);  
	        }  
	    }  
	 public static void quickSort(int[] array,int left,int right){
		 int middle;
		 if(left<right){
			 middle=getMiddle(array,left,right);//获得中间的位置
			 quickSort(array,left,middle-1);//遍历左面的
			 quickSort(array,middle+1,right);//遍历右面的
		 }
	 }
	 public static int getMiddle(int [] array,int left,int right){
		 int middleValue=array[left];
		 int middleIndex=left;
		 while(left<right){
			 while(left < right && array[right]>=middleValue) right--;
			 array[left]=array[right];
			 while(left < right && array[left]<=middleValue) left++;
			 array[right]=array[left];
		 }
		
		 if(left==right){//如果左右相等第一次遍历完成
			 middleIndex=left;//left、right都可以
			 array[middleIndex]=middleValue;//把中间值放到空缺位置
			 
		 } 
		 return middleIndex;
		 
	 }
}

转载于:http://blog.csdn.net/xuxurui007/article/details/7639863