算法之快速排序

Java code:

package com.cn.insertion;

import java.util.Random;

/**
 * 快速排序在最坏的情况下的时间复杂度为O(n*n),平均与最好的情况的时间
 * 复杂度为O(nlog(n))。快速排序的主要思想是每一次选定一个Key值，然后
 * 把大于key的数放到key后面，把小鱼key的数放到key的前面，这样key的位
 * 置就确定了。
 * @author Administrator
 *
 */
public class QuickSort {
	public static void main(String[] args) {
		int[] a = new int[] {10,12,8,5,23,5,3,13,9,11}; 
		quickSort(a, 1, 10);
		for (int i = 0; i< a.length; i++) {
			System.out.println(a[i]);
		}
	}
	/**
	 * 递归。int q = partion(a, r, p);这一句会将一个key值放到合适的位置
	 * 然后再递归的排序前一段与后一段。
	 * @param a
	 * @param r
	 * @param p
	 */
	public static void quickSort(int[] a, int r, int p) {
		if (r < p) {
			int q = partion(a, r, p);
			//int q = optPartion(a, r, p);//这是优化了
			quickSort(a, r, q - 1);
			quickSort(a, q + 1, p);
		}
	}
	
	/**
	 * 找到一个key在有序的数组的应该的位置并返回。
	 * @param a
	 * @param r
	 * @param p
	 * @return
	 */
	public static int partion(int[] a, int r, int p) {
		int i = r - 1;
		int key = a[p - 1];
		int j;
		for (j = r; j  < p; j++) {
			if (a[j - 1] < key) {
				i++;
				exchange(a, i, j);
			}
		}
		i ++;
		exchange(a, i, j);
 		return i;
	}
	//对数组中的两个元素进行交换
	public static void exchange(int[] a, int m, int n) {
		if (m == n) {
			return;
		}
		a[m - 1] = a[m - 1] + a[n - 1];
		a[n - 1] = a[m - 1] - a[n - 1];
		a[m - 1] = a[m - 1] - a[n - 1];
	}
	
	/**
	 * 优化了的排序，防止最坏的情况出现，当需要排序的数组已经是升序的
	 * 或者是降序的，这是就是最坏的情况，这是的时间复杂度为O(n*n)。
	 * 优化的办法是每次寻找key时，我们从数组随机的寻找一个。
	 * @param a
	 * @param r
	 * @param p
	 * @return
	 */
	public static int optPartion(int[] a, int r, int p) {
		Random random = new Random();
		int u = random.nextInt(p - r + 1) + r;
		int key = a[u - 1];
		exchange(a, p, u);
		int i = r - 1;
		int j;
		for (j = r; j  < p; j++) {
			if (a[j - 1] < key) {
				i++;
				exchange(a, i, j);
			}
		}
		i ++;
		exchange(a, i, j);
 		return i;
	}
}