Java快速排序算法整理(二)

package boke.sort;

/**
 * 快速排序
 * 
 * @since jdk1.5及其以上
 * @author 毛正吉
 * @version 1.0
 * @date 2010.05.24
 * 
 */
public class QuickSort2 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int maxSize = 10000;
		QuickSort2 bs = new QuickSort2(maxSize);

		for (int i = 1; i <= 100; i++) {
			int v = (int) (Math.random() * 101);
			bs.insert(v);
		}
		bs.output(); // 原始输出
		bs.quickSort(); // 排序
		bs.output(); // 排序输出

	}

	private long[] a; // 整型数据容器
	private int nElems; // 元素个数

	/**
	 * 构造方法
	 * 
	 * @param maxSize
	 */
	public QuickSort2(int maxSize) {
		a = new long[maxSize];
		nElems = 0;
	}

	/**
	 * 容器放入数据
	 * 
	 * @param value
	 */
	public void insert(long value) {
		a[nElems++] = value;
	}

	/**
	 * 输出容器数据
	 */
	public void output() {
		for (int j = 0; j < nElems; j++) {
			System.out.print(a[j] + " ");
		}
		System.out.println("");
	}

	/**
	 * 快速排序
	 */
	public void quickSort() {
		recQuickSort(0, nElems - 1);
	}

	/**
	 * 快速排序
	 * 
	 * @param left
	 * @param right
	 */
	private void recQuickSort(int left, int right) {
		int size = right - left + 1;

		if (size <= 3) {
			manualSort(left, right);
		} else {
			long median = manualOf3(left, right);
			int partition = partitionIt(left, right, median);
			recQuickSort(left, partition - 1); // 左段排序
			recQuickSort(partition + 1, right); // 右段排序
		}
	}

	/**
	 * 
	 * @param left
	 * @param right
	 * @return
	 */
	private long manualOf3(int left, int right) {
		int center = (left + right) / 2;

		if (a[left] > a[center]) { // 排序： left & center
			swap(left, center);
		}
		if (a[left] > a[right]) { // 排序： left & right
			swap(left, right);
		}
		if (a[center] > a[right]) { // 排序： center & right
			swap(center, right);
		}
		swap(center, right - 1);
		return a[right - 1];
	}

	/**
	 * 
	 * @param left
	 * @param right
	 */
	private void manualSort(int left, int right) {
		int size = right - left + 1;

		if (size <= 1) {
			return;
		}

		if (size == 2) {
			if (a[left] > a[right]) {
				swap(left, right);
			}
			return;
		} else {
			if (a[left] > a[right - 1]) {
				swap(left, right - 1); // left,center
			}
			if (a[left] > a[right]) {
				swap(left, right); // left, right
			}
			if (a[right - 1] > a[right]) {
				swap(right - 1, right); // center, right
			}
		}

	}

	/**
	 * 快速排序
	 * 
	 * @param left
	 * @param right
	 * @param pivot
	 * @return
	 */
	private int partitionIt(int left, int right, long pivot) {
		int leftPtr = left;
		int rightPtr = right - 1;

		while (true) {
			while (a[++leftPtr] < pivot) {
				;
			}

			while (a[--rightPtr] > pivot) {
				;
			}

			if (leftPtr >= rightPtr) {
				break;
			} else {
				swap(leftPtr, rightPtr);
			}
		}
		swap(leftPtr, right - 1);
		return leftPtr;
	}

	/**
	 * 交换
	 * 
	 * @param leftPtr
	 * @param rightPtr
	 */
	private void swap(int leftPtr, int rightPtr) {
		long temp = a[leftPtr];
		a[leftPtr] = a[rightPtr];
		a[rightPtr] = temp;

	}
}