七种基本排序（2）——快速排序

快速排序（Note）

快速排序框架

快速排序思想就是找到一个基准值，然后让比它小的在它前面，比它大的在它后面

然后用递归思想解决比它小的一部分和比它大的一部分区间

注释：

partiton作用：分割

index：记录基准值的下标位置

    public static void quickSort(int[] array) {
       InnerquickSort(array,0,array.length-1);
    }
    public static void InnerquickSort(int[] array,int left,int right) {	
    if(left>right) return;
    int index=partition3(array,left,right);
    InnerquickSort(array,left,index-1);
    InnerquickSort(array,index+1,right);
    }

 这里介绍方法partition（）分割是如何实现的，基本有4种方法，这里介绍3种，

第一种方法【交换法】

核心：从左边数起较大的元素与从右起较小的元素进行交换

第二种方法【挖坑法】

数据结构书上最常用的方法，虽然时间复杂度不会改变，但是相对比起其他几种方法来说花时间较少

第三种方法【较小元素交换】

for循环找到相对小的元素，另一个指针red

第四种方法【相同元素归并至中间】

不做具体介绍返回值以数组形式放回

private static int partition(int[] array, int left, int right) {
		// TODO 自动生成的方法	
	int pivot=array[right];
	int p=left;
	int q=right;
	while(p<q) {
		while(p<q&&array[p]<=pivot) {
			p++;
		}
		while(p<q&&array[q]>=pivot) {
			q--;
		}
		wrap(array,p,q);
	}
	wrap(array,p,right);
		return p;
	}
private static int partition2(int[] array,int left,int right) {
	int pivot=array[right];
	int p=left;
	int q=right;
	while(p<q) {
		while(p<q&&array[p]<=pivot) {
			p++;
		}
		array[q]=array[p];
		while(p<q&&array[q]>=pivot) {
			q--;
		}
		array[p]=array[q];
	}
	if(p==q)
	array[p]=pivot;
		return p;
	}
public static int partition3(int[] array,int left,int right) {
	int pivot=array[right];
	int red=left;
	//找出相对小的元素不断交换
	//red进行遍历，i不停地找相对小的元素
	//red与i进行交换
	for(int i=red;i<right;i++) {
		if(array[i]<pivot) {
			wrap(array,red,i);
			red++;
		}
	}
	wrap(array,red,right);
	return red;
}

测试

public static void main(String[] args) {
	int[] array= {3,4,6,2,6,2,1,3};
	quickSort(array);
	System.out.println(Arrays.toString(array));
}