算法笔记4：快速排序

标准快速排序

import java.util.Random;
/**
 * 标准快速排序
 * @author XY
 *
 */
@SuppressWarnings("rawtypes")
public class QuickSort {
	
	public static void sort(Comparable[] v){
		shuffle(v);//随机打乱数组
		int N=v.length;
		sort(v, 0, N-1);
	}
	public static void sort(Comparable[] v,int lo,int hi){
		if(lo>=hi) return;
		int j=position(v, lo, hi);//找到切分点，切分点的位置已经排定
		sort(v, lo, j-1);
		sort(v, j+1, hi);		
	}
	private static int position(Comparable[] v,int lo,int hi){
		//找到切分位置j，保证j的左边小于等于v[lo],右边大于等于v[lo]
		int i=lo;
		int j=hi+1;
		Comparable low=v[lo];
		while(true){
			while(less(v[++i], low)) if(i==hi) break;
			//从左到右遇到的不小于v[lo]的元素
			while(less(low, v[--j])) if(j==lo) break;
			//从右到左遇到的不大于v[lo]的元素
			if (j>i) {//左右指针还未相遇，交换
				Comparable temp=v[i];
				v[i]=v[j];
				v[j]=temp;
			} else  break;				
			
		}
		v[lo]=v[j];
		v[j]=low;//交换v[j]和v[lo],v[i]>=v[lo],v[j]<=v[lo],所以选择j为切分位置
		return j;
	}
	private static void shuffle(Comparable[] v){//随机打乱数组
		int n=v.length;
		Random r=new Random();
		for (int i = 0; i < v.length; i++) {
			int x=i+r.nextInt(n-i);
			Comparable temp=v[i];
			v[i]=v[x];
			v[x]=temp;
		}
	}
	
	public static boolean less(Comparable a, Comparable b) {
		return a.compareTo(b) < 0;
	}
	
	public static boolean issorted(Comparable[] v) {
		for (int i = 0; i < v.length - 1; i++) {
			if (less(v[i + 1], v[i]))
				return false;
		}
		return true;
	}
	public static void show(Comparable[] v){
		StringBuffer sb=new StringBuffer();
		for (int i = 0; i < v.length; i++) {
			sb.append(" "+v[i]);
		}
		System.out.println(sb.toString());
	}
	
	public static void main(String[] args){
		Double[] n={1.2,3.5,8.2,0.5,1.8,2.9,3.0,4.5,0.3,0.1,5.3,2.9,4.2,8.0,7.6};
		sort(n);
		show(n);
		System.out.println(issorted(n));
	}

}

三取样切分和小段插入排序的快速排序

为了使得每次切分的位置尽可能的接近N/2，使用随机三个数的中位数。在数组长度小于10时使用插入排序。

import java.util.Random;
/**
 * 使用三取样中位数和小段插入排序的快速排序
 * @author XY
 *
 */
@SuppressWarnings("rawtypes")
public class QuickSortB {
	public static void sort(Comparable[] v){
		shuffle(v);
		int N=v.length;
		sort(v, 0, N-1);
	}
	private static void sort(Comparable[] v,int lo,int hi){
		if(hi-lo<10){//快速排序的切换值一般在5-15之间
			InsertSort.sort(v, lo, hi);	return; 	}
		int mid=mid(v, lo, lo+(hi-lo)/2, hi);//找到随机三个数的中位数作为v[lo]
		exchange(v, lo, mid);
		int j=position(v, lo, hi);
		sort(v, lo, j-1);
		sort(v, j+1, hi);
		
	}
	public static int mid(Comparable[] v,int i,int j,int k){
		
		int a=v[j].compareTo(v[i]);
		int b=v[j].compareTo(v[k]);
		int c=v[i].compareTo(v[k]);
		if(a*b<0) return j;
		if(b*c>0) return i;		
		return k;
	}
	
	private static int position(Comparable[] v,int lo,int hi){
		int i=lo;
		int j=hi+1;
		Comparable low=v[lo];
		while(true){
			while(less(v[++i], low)) {if(i==hi) break;}
			while(less(low, v[--j])) {}
			if (j>i) {
				Comparable temp=v[i];
				v[i]=v[j];
				v[j]=temp;
			} else  break;				
			
		}
		v[lo]=v[j];
		v[j]=low;
		
		return j;
	}
	private static void shuffle(Comparable[] v){//随机打乱数组
		int n=v.length;
		Random r=new Random();
		for (int i = 0; i < v.length; i++) {
			int x=i+r.nextInt(n-i);
			Comparable temp=v[i];
			v[i]=v[x];
			v[x]=temp;
		}
	}
	public static boolean less(Comparable a, Comparable b) {
		return a.compareTo(b) < 0;
	}

	public static void exchange(Comparable[] v, int a, int b) {
		Comparable w = v[a];
		v[a] = v[b];
		v[b] = w;
	}
	
	public static boolean issorted(Comparable[] v) {
		for (int i = 0; i < v.length - 1; i++) {
			if (less(v[i + 1], v[i]))
				return false;
		}
		return true;
	}
	public static void show(Comparable[] v){
		StringBuffer sb=new StringBuffer();
		for (int i = 0; i < v.length; i++) {
			sb.append(" "+v[i]);
		}
		System.out.println(sb.toString());
	}
	public static void main(String[] args){
		Double[] n={1.2,3.5,8.2,0.5,1.8,2.9,3.0,4.5,0.3,0.1,5.3,2.9,4.2,8.0,7.6};
		
		sort(n);
		show(n);
		System.out.println(issorted(n));
	}

}