算法学习之排序学习之快速排序

　　快速排序，对包含n个数的数组进行排序，最坏运行时间O(n2)，期望的运行时间O(nlgn)。

　　快速排序基本思想，基于分治模式的，先找其中一个数为中间数，然后根据中间数将数组分为两个部分，左边比中间数小，右边比中间数大，然后对左边和右边两部分子数组分别递归调用快速排序，由于两个子数组是就地排序的，合并他们不需要操作，整个数组已经有序了。

　　具体看代码，下面代码给出了两种实现。

package sort;

public class QuickSort {
	/** **********Hore 实现************ */
	/**
	 * 先空出最左边的值作为中间数，从右边开始找，直到遇到比中间数小的，交换位置，
	 * 然后从左边开支找，直到找到比中间数大的，交换位置，直到两边相遇。将最后空出的位置填入中间数。 并返回下标。
	 * 
	 * @param data
	 *            要排序的数组
	 * @param left
	 *            要排序的起始下标
	 * @param right
	 *            要排序的终止下标
	 * @return 返回找到的中间数下标
	 */
	public int partition(int[] data, int left, int right) {
		int i, j, middle;
		i = left;
		j = right;
		middle = data[left];
		while(i < j){
			while (j > i && data[j] >= middle) {
				j--;
			}
			data[i] = data[j];
			while (i < j && data[i] <= middle ) {
				i++;
			}
			data[j] = data[i];
		}
		data[i] = middle;
		return i;
	}

	/**
	 * 找到中间的下标，然后分治，分解成子数组，然后分别递归快速排序
	 * 
	 * @param data
	 *            要排序的数组
	 * @param left
	 *            要排序的起始下标
	 * @param right
	 *            要排序的终止下标
	 */
	public void quickSort(int[] data, int left, int right) {
		if(left < right){
			int midIndex = this.partition(data, left, right);
			quickSort(data, left, midIndex - 1);
			quickSort(data, midIndex + 1, right);
		}
	}

	/** **************算法导论实现**************** */
	/**
	 * 快速排序，伪代码： 
	 * QUICKSORT(A, p, r) 
	 * 1 if p < r 
	 * 2 then q ← PARTITION(A, p, r) 
	 * 3 QUICKSORT(A, p, q - 1) 
	 * 4 QUICKSORT(A, q + 1, r)
	 * 
	 * PARTITION(A, p, r) 
	 * 1 x ← A[r] 
	 * 2 i ← p - 1 
	 * 3 for j ← p to r - 1 
	 * 4 do if A[j] ≤ x 
	 * 5 then i ← i + 1 
	 * 6 exchange A[i] ↔ A[j] 
	 * 7 exchange A[i + 1] ↔ A[r] 
	 * 8 return i + 1 
	 * 复杂度，最坏情况下：Θ(n^2) 一般平衡情况：Θ(nlgn)
	 * 
	 * @param array
	 *            待排数组
	 * @param from
	 *            起始位置
	 * @param to
	 *            终止位置
	 */
	public int partition1(int[] array, int from, int to){
		int temp = array[to];
		int i = from - 1;
		for (int j = from; j < to; j++) {
			// 分为两部分from~i，i+1~to
			if (array[j] <= temp) {
				i++;
				// 互相交换a[i]与a[j]
				int tempValue = array[j];
				array[j] = array[i];
				array[i] = tempValue;
			}
		}
		// 交换最后一个数和中间位置的数
		array[to] = array[i + 1];
		array[i + 1] = temp;
		return i + 1;
	}
	@SuppressWarnings("unused")
	private void quickSortTwo(int[] array, int from, int to) {
		if (from < to) {
			int mid = partition1(array, from, to);
			quickSortTwo(array, from, mid - 1);
			quickSortTwo(array, mid + 1, to);
		}
	}

	public static void main(String[] args) {
		QuickSort quickSort = new QuickSort();
		System.out.println("Hore实现：");
		int[] data = { 5, 4, 6, 3, 9, 2, 8, 10, 7 };
		quickSort.quickSort(data, 0, data.length - 1);
		for (int i : data) {
			System.out.print(i + ",");
		}
		System.out.println("\n算法导论实现：");
		int[] data1 = { 5, 4, 6, 3, 9, 2, 8, 10, 7 };
		quickSort.quickSortTwo(data1, 0, data1.length - 1);
		for (int i : data1) {
			System.out.print(i + ",");
		}
	}

}

结果截图如下：