快速排序（java实现）

定义一个数据包装类：

package sorted;

public class DataWrap implements Comparable<DataWrap>{
	int data;
	String flag;
	public DataWrap(int data,String flag){
		this.data=data;
		this.flag=flag;
	}
	public String toString(){
		return data+"_"+flag;
	}
	public int compareTo(DataWrap dw){
		return this.data>dw.data ? 1:(this.data==dw.data? 0 : -1);
	}
}

快速排序算法如下：

package sorted;

import java.util.Arrays;
/**
 *	时间复杂度：最快达到O(n*logn)
 *	空间复杂度：O(logn) 
 *	是不稳定的算法
 */
public class QuickSortDemo {
	//数据交换
	private static void swap(DataWrap[] data,int i,int j){
		DataWrap tmp;
		tmp=data[j];
		data[i]=data[j];
		data[j]=tmp;
	}
	//对data数组中从start到end索引范围的子序列进行处理
	//使之满足所有小于分界值的放在左边，所有大于分界值的放在右边
	private static void subSort(DataWrap[] data,int start,int end){
		//需要排序
		if(start<end){
			//以第一个元素作为分界值
			DataWrap base =data[start];
			//i从左边开始搜索，搜索大于分界值 的元素索引
			int i=start;
			//j从右边开始搜索，搜索小于分界值的元素的索引
			int j=end+1;
			while(true){
				//找到大于分界值的元素的索引，或i已经到了end处
				while(i<end && data[++i].compareTo(base)<=0);
				//找到小于分界值的元素的索引，或j已经到了start处
				while(j>start && data[--j].compareTo(base)>=0);
				if(i<j){
					swap(data,i,j);
				}else{
					break;
				}
			}
			swap(data,start,j);
			//递归左边子序列
			subSort(data,start,j-1);
			//递归右边子序列
			subSort(data,j+1,end);
		}
	}
	
	public static void quickSort(DataWrap[] data){
		subSort(data,0,data.length-1);
	}
	public static void main(String args[]){
		DataWrap[] data={
				new DataWrap(9,""),
				new DataWrap(-16,""),
				new DataWrap(21,"*"),
				new DataWrap(23,""),
				new DataWrap(-30,""),
				new DataWrap(-49,""),
				new DataWrap(21,""),
				new DataWrap(30,"*"),
				new DataWrap(13,"*") 
		};
		System.out.println("排序之前：\n"+Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n"+Arrays.toString(data));
	}
	
}

运行结果：