快速排序解析（JAVA实现）

快速排序是一种“分而治之”的排序算法，通过随机选择“分区点”来避免出现最坏的情况，排序的效率较高。

比如说一个数组A，我们可以随机选择一个中心值KEY，比如说A[0]，通过遍历交换可以将数组A分成以KEY为中心两个部分，KEY左边的数都比KEY小，KEY右边的数都比KEY大，然后对左右两部分再次运用以上算法，直到排序完成。
我们来递归调用以下算法就可以完成快速排序算法：
1，定义 i = 0，j = A.length - 1，i 为第一个数的下标，J为最后一个数下标
2，从数组的最后一个数Aj从右往左找，找到第一小于key的数，记为Aj；
3，从数组的第一个数Ai 从左往右找，找到第一个大于等于KEY的数，记为Ai;
4，交换 Ai 和 Aj  
5，重复这个过程，直到  i = j
6，调整key的位置，把A[i] 和key交换

 

假设要排的数组为：A[8] ={ 5 2 8 9 2 3 4 9 }

选择 key = 5， 开始时 i=0，j=7

index         0    1    2    3    4    5    6    7

 

开始：       5    2    8    9    2    3    4    9

                  i                                         j  

第一次找   5    2    8    9    2    3    4    9

                              i                       j

交换：       5    2    4    9    2    3    8    9 

                              i                       j

第二次找   5    2    4    9    2    3    8    9

                                    i           j

交换：       5    2    4    3    2    9    8    9

                                    i            j

第三次找    5    2    4    3    2    9    8    9

                                          ij   

调整key： 2    5    4    3    5    9    8    9

 

JAVA实现的代码如下：

package chenxiloong;

import java.util.Arrays;

public class QuickSort {

	 public static void main(String[] args) {  
	        int[] a = {1, 2, 4, 5, 7, 4, 5 ,3 ,9 ,0};  
	        System.out.println(Arrays.toString(a));  
	        quickSort(a);  
	        System.out.println(Arrays.toString(a));  
	    }  
	  
	    public static void quickSort(int[] a) {  
	        if(a.length>0) {  
	            quickSort(a, 0 , a.length-1);  
	        }  
	    }  
	    private static void quickSort(int[] a, int low, int high) {  
	        //1,找到递归算法的出口  
	        if( low > high) {  
	            return;  
	        }  
	        //2, 存  
	        int i = low;  
	        int j = high;  
	        //3,key  
	        int key = a[ low ];  
	        //4，完成一趟排序  
	        while( i< j) {  
	        	//4.1 ，从右往左找到第一个小于key的数  
	            while(i<j && a[j] > key){  
	                j--;  
	            } 
	            // 4.2 从左往右找到第一个大于等于key的数  
	            while( i<j && a[i] <= key) {  
	                i++;  
	            }
	            System.out.println("i====="+i+"=======j======"+j);
	            System.out.println("key====="+key+"=======执行过程========"+Arrays.toString(a));
	            //4.3 交换  
	            if(i<j) {  
	                int p = a[i];  
	                a[i] = a[j];  
	                a[j] = p;  
	            }
	            System.out.println("key====="+key+"=======执行过程========"+Arrays.toString(a));
	        }  
	        System.out.println("调整key的位置");
	        // 4.4，调整key的位置  
	        int p = a[i];  
	        a[i] = a[low];  
	        a[low] = p;  
	        //5, 对key左边的数快排  
	        quickSort(a, low, i-1 );  
	        //6, 对key右边的数快排  
	        quickSort(a, i+1, high);  
	    }  
}