快速排序

快速排序对比合并排序效率和空间占用率有很大的优势

 

package com.woxiaoe.algorithm.sort;

import java.util.Arrays;
import java.util.Random;

/**
 * 快速排序
 * @author 小e
 *
 * 2010-4-5 下午09:50:11
 */
public class Qsort {
	/**
	 * 
	 * @param a
	 * @param left
	 * @param right 长度
	 */
	public static void sort(Comparable[] a,int left,int right){
		if(left < right){
			int index = randomPartition(a,left,right);
			sort(a, left, index - 1 );
			sort(a, index + 1,  right);
		}
		
	}
	
	/**
	 * 随机选一个点作为分割点，同时排序
	 * @param a
	 * @param left
	 * @param right
	 * @return
	 */
	private static int partition(Comparable[] a, int left, int right) {
		Comparable d = a[left];//取到的值
		int i = left;
		int j = right + 1;
		while(true){
			while(a[++i].compareTo(d) < 0 && i < right);
			while(a[--j].compareTo(d)>0);
			if(i>=j){
				break;
			}
			swap(a, i, j);
		}
		a[left] = a[j];
		a[j] = d;
		return j;
	}
	private static Random r = new Random();//如果r在方法内初始化，会造成重复初始化，对效率影响很大
	public static int randomPartition(Comparable[] a,int left,int right){
		//经测试随机取位置效率低于取第一位，估计效率的开销应该在取随机数
		//int index =  left +  (int)(Math.random()*(right - left - 1));
		//int index =  left +  (int)(r.nextDouble()*(right - left - 1));
		//swap(a, left, index);
		return partition(a, left, right);
	}
	public static void swap(Comparable[] a ,int i,int j){
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	
	
}

 测试类

package com.woxiaoe.algorithm.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

/**
 * 排序算法测试类
 * @author 小e
 *
 * 2010-4-5 下午10:02:21
 */
public class SortClient {
	public static int LIST_SIZE = 1;
	public static int ARRAY_SIZE = 3000000;
	
	
	public static void main(String[] args) {
		long start = 0;
		List<Comparable[]> list = new ArrayList<Comparable[]>();
		initDate(list);
		start = System.currentTimeMillis();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Comparable[] items = (Comparable[]) iterator.next();
			//System.out.println("in" + Arrays.toString(items));
			Qsort.sort(items, 0, items.length-1);
			//System.out.println("out" + Arrays.toString(items));
			//System.out.println(testArray(items));
			
		}
		System.out.println("快速排序用时:" + (System.currentTimeMillis() - start) + "ms");
		
		/*initDate(list);
		//System.out.println("in" + Arrays.toString(items));
		start = System.currentTimeMillis();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Comparable[] items = (Comparable[]) iterator.next();
			//System.out.println("in" + Arrays.toString(items));
			Arrays.sort(items);
			//System.out.println("out" + Arrays.toString(items));
			//System.out.println(testArray(items));
			
		}
		System.out.println("jdk版本用时:" + (System.currentTimeMillis() - start) + "ms");*/
		
		initDate(list);
		start = System.currentTimeMillis();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Comparable[] items = (Comparable[]) iterator.next();
			//System.out.println("in" + Arrays.toString(items));
			sort(items,2);
			//System.out.println("out" + Arrays.toString(items));
			
		}
		System.out.println("第二个版本用时:" + (System.currentTimeMillis() - start) + "ms");
	}
	

	public static void sort(Comparable[] items,int version){
		MergeSort.mergeSortManager(items,version);
	}
	public static List<Comparable[]> initDate(List<Comparable[]> list){
		
		Random r = new Random();
		if(list.size() == 0){
			list.add(new Item[ARRAY_SIZE]);
		}
		for(int i = 0; i<LIST_SIZE; i++){
			Item[] items = null;
			if(list.size() > i){
				items = (Item[]) list.get(i);
			}else{
				items = new Item[ARRAY_SIZE];
				list.add(items);
			}
			for(int j = 0; j < ARRAY_SIZE; j++){
				if(items[j] == null){
					items[j] = new Item(r.nextInt(1000));
				}else{
					items[j].setData(r.nextInt(1000));
				}
				
			}
		}
		return list;
	}
	public static boolean testArray(Comparable[] a){
		int len = a.length;
		for(int i = 0; i<len - 1; i++){
			if(a[i].compareTo(a[i+1])>0){
				return false;
			}
		}
		return true;
	}

}
class SortItem implements Comparable {
	private int data;
	public SortItem(int data) {
		this.data = data;
	}
	public SortItem() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public int compareTo(Object o) {
		Item t = (Item)o;
		return this.data - t.getData();
	}
	public int getData() {
		return data;
	}
	public void setData(int data) {
		this.data = data;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return this.data + "";
	}
	
	
}

 output

快速排序用时:4234ms

其他两个内存溢出