Syong : 快速排序

快速排序

What
快速排序（Quick Sort），是一种优秀的排序算法，它的时间复杂度为O（nlog2n），其核心是一种分治思想。通过一个基准，把数组分为大小两个部分，然后这两个部分再通过各自的基准继续分，直到区间只剩1个元素（这里可以优化，不一定是一个）返回。可以通过递归的方法实现，也可以通过栈的方法实现。

How
java代码

//测试类
public class Test {
    public static void main(String []args) {
  	int[] array = {1,9,8,2,7,3,4,6,5};
  	Quick.sort(array,0,8);
  	for ( int i : array ) {
   	    System.out.println(i);
  	}
    }
}
class Quick{
    //快速排序算法：对int[]数组升序排序
    public static void sort(int[] array,int left,int right) {
        if ( right <= left ) return;
	int pivot = left;//设定基准下标
  	int index = left + 1;//基准左右分割点下标
  	for ( int i = left+1 ; i <= right ; i ++ ) {
   	    if ( array[i] < array[pivot] ) {
    	    	//swap
    		swap(array,i,index);
    		//基准左右分割点下标+1
    		index ++;
   	    }
        }
        //swap again;
    	swap(array,pivot,index-1);
    	sort(array,left,index-1);
    	sort(array,index,right);
    	return;
   }
   //交换值
   public static void swap(int[] array,int i,int j) {
  	if ( i != j ) {
   	    array[i] = array[i] + array[j];
   	    array[j] = array[i] - array[j];
   	    array[i] = array[i] - array[j];
  	}
   }
}

left与right参数，是将要排序或操作作的区间；

pivot是基准，可以看到，我给出得代码里面，pivot得取值总是区间的left值；然后通过比较pivot把[left，right]区间分割为[left，index-1]与[index，right]，两个区间，区间[left，index-1]的值总是小于等于array[pivot]，区间[index，right]的值总是大于array[pivot]

循环以上步骤，直到所有sort()出栈；

以上代码sort()方法执行了19次，每一次获得不同得array：

运行sort(),jvm里得栈帧类似：
第一次运行sort(),left=0,right=8,array{1,9,8,2,7,3,4,6,5}
第二次运行sort(),left=0,right=0,array{1,9,8,2,7,3,4,6,5}
第三次运行sort(),left=1,right=8,array{1,9,8,2,7,3,4,6,5}
第四次运行sort(),left=1,right=7,array{1,5,8,2,7,3,4,6,9}
第五次运行sort(),left=1,right=4,array{1,4,2,3,5,8,7,6,9}
第六次运行sort(),left=1,right=3,array{1,3,2,4,5,8,7,6,9}
第七次运行sort(),left=1,right=2,array{1,2,3,4,5,8,7,6,9}
第八次
…

上面的代码只是简单实现，还可以继续优化，例如
1.基准的制定，可以随机查找等等；
2.返回的判定条件，不一定要只剩一个元素才return；可以剩三个以下元素时进行比较交换值，减少JVM创建栈帧，提高性能；
3.像java的Array.sort()一样，结合别的排序算法；

When & Where
java中的Array.sort()方法涉及了一些快速排序，显然不止快速排序，还有归并排序，

结束语：优秀是一种习惯