改进后的快速排序--ImprovedQuickSort

对于快速排序的改进，通常可以从以下几个方面入手

1、切换到插入排序。当数组比较小，插入排序性能要优于快速排序

2、三取样切分。使用子数组的一小部分元素的中位数来切分数组。

3、三向切分。将数组切分成三个部分，分别对应小于、等于和大于切分元素的数组。

三向切分的具体实现步骤

1、选取随机数作为枢轴。

2、使用左端，右端和中心的中值做为枢轴元。

3、每次选取数据集中的中位数做枢轴。

最近看了一本叫《算法Algorithm》的书，里面介绍了一种算法模型，简单说这种模型就是将所有算法都会用到的方法用一个类封装起来以便调用

代码实现

public class ImprovedQuickSort implements Sort {

	public void sort(int[] data) {
		int[] stack = new int[9999];    //定义一个长度为9999的数组用于存放排列后的数据
		int top = -1;
		int pivot;   //枢轴
		int pivotIndex, l, r;

		stack[++top] = 0;
		stack[++top] = data.length - 1;

		while (top > 0) {
			int j = stack[top--];
			int i = stack[top--];

			pivotIndex = (i + j) / 2;
			pivot = data[pivotIndex];

			SortUtil.swap(data, pivotIndex, j);

			//分割过程
			l = i - 1;
			r = j;
			do {
				while (data[++l] < pivot)
					;
				while ((r != 0) && (data[--r] > pivot))
					;
				SortUtil.swap(data, l, r);
			} while (l < r);
			SortUtil.swap(data, l, r);
			SortUtil.swap(data, l, j);

			if ((l - i) > 0) {
				stack[++top] = i;
				stack[++top] = l - 1;
			}
			if ((j - l) > 0) {
				stack[++top] = l + 1;
				stack[++top] = j;
			}
		}
		insertSort(data);
	}

	
	private void display(int[] data) {
		for (int result : data) {
			System.out.print(result+"  ");
		}
	}

	/**
	 * 插入排序
	 * @param data
	 */
	private void insertSort(int[] data) {
		int temp;
		for (int i = 1; i < data.length; i++) {
			for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
				SortUtil.swap(data, j, j - 1);
			}
		}
	}
	
	public static void main(String[] args) {
		int[] array = {20,12,10,1,4,19,90,34,33,36,92,11};
		ImprovedQuickSort sort = new ImprovedQuickSort();
		sort.sort(array);
		sort.display(array);
	}
	
}

那个算法模型我把它定义为一个SortUtil类，在后面的排序算法中会多次用到这个类

public class SortUtil {

	public final static int IMPROVED_QUICK = 1;

	public static void sort(int[] data) {
		sort(data, IMPROVED_QUICK);
	}

	private static String[] name = { "improved_quick" };

	private static Sort[] impl = new Sort[] { new ImprovedQuickSort() };

	public static String toString(int algorithm) {
		return name[algorithm - 1];
	}

	public static void sort(int[] data, int algorithm) {
		impl[algorithm - 1].sort(data);
	}

	public static interface Sort {
		public void sort(int[] data);
	}

	public static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}
}