Java数据结构之 快速排序的优化

一. 数据元素较少时用直接插入

具体实现见代码：

//直接插入排序
	public static void insertSort(int[] array,int start,int end){
		int tmp = 0;
		int j;
		for(int i = start+1;i < end;i++){//从i号位值开始
			tmp = array[i];
			for(j = i-1;j >= 0;j--){
				if(array[j] > tmp){
					array[j+1] = array[j];
				}
				//在循环中找到了比tmp小的第一个元素跳出循环
				else{
					break;
				}
			}
			//把tmp赋值到最小值的后面
			array[j+1] = tmp;
		}
	}
	public static int partition(int[] array,int start,int end){//返回基准的下标
		int low = start;
		int high = end;
		int tmp = array[low];
		while(low < high){
			while(low < high&&array[high] >= tmp){//从后往前找比基准小的后退出循环
				--high;
			}
			if(low >= high){//判断low与high是否相遇
				break;
			}else{
				array[low] = array[high];
			}
			while(low < high&&array[low] <= tmp){//从前往后找比基准大的退出循环
				++low;
			}
			if(low >= high){
				break;
			}else{
				array[high] = array[low];
			}
		}
		array[low] = tmp;
		return low;
	}
	public static void quick(int[] array,int start,int end){
		//优化，小于100用直接插入排序
		if((end-start+1) < 100){
			insertSort(array,start,end);
		}	
		int par = partition(array, start, end);
		if(par > start+1){//左半部分在进行快排
			quick(array, start, par-1);
		}
		if(par < end - 1){//右半部分进行快排
			quick(array, par+1, end);
		}
	}
	public static void quickSort(int[] array){
		int low = 0;
		int high = array.length - 1;
		quick(array, low, high);
	}

二. 聚集相同元素

聚集相同元素法就是进行一次快速排序之后，将与基准相同的都移到基准的附近。

例：

接下来可以将左右par左右两边的12移到基准12附近

交换后如图：

这样就将与par相等的元素聚集在了一起。接下来看一下具体的代码。

public static int[] focusNum(int[] array,int start,int end,int par,int left,int right){
		//找左边
		int parLeft = par-1;//基准左边的
		int parRight = par+1;//基准右边的
		int tmp = 0;
		for(int i = par-1;i >= start;i--){
			if(array[par] == array[i]){//与基准相同
				if(i != parLeft){//判断与parLeft是否一样，不一样进行交换
					//交换
					tmp = array[parLeft];
					array[parLeft] = array[i];
					array[i] = tmp;
					parLeft--;
				}else{//一样应该将parLeft--，因为此时的parLeft与基准已经相同。
					parLeft--;
				}
			}
		}
		left = parLeft;//最后的parLeft指向的是聚集后与基准相同的最后一个元素的左边的下标
		//找右边，与左边相同
		for(int i = par+1;i <= end;i++){
			if(array[par] == array[i]){
				if(i != parRight){
					tmp = array[parRight];
					array[parRight] = array[i];
					array[i] = tmp;
					parRight++;
				}else{
					parRight++;
				}
			}
		}
		right = parRight;//最后的parRight指向的是聚集后与基准相同的最后一个元素的右边的下标
		int[] b = new int[2];
		b[0] = left;
		b[1] = right;
		return b;//将这个数组返回
	}
	public static void quick(int[] array,int start,int end){
		
		int par = partition(array, start, end);
		int left = par-1;
		int right = par+1;
		//System.out.println(par+" "+left+" "+right);
		int[] b = focusNum(array, start, end, par, left, right);
		left = b[0];
		right = b[1];
		if(par > start+1){//对聚集区域左边进行快速排序
			quick(array, start, left);
		}
		if(par < end - 1){//聚集区域右边进行快速排序
			quick(array, right, end);
		}
	}