快速排序——算法导论(8)

1. 算法描述

    快速排序(quick-sort)与前面介绍的归并排序(merge-sort)（见算法基础——算法导论(1)）同样，使用了分治思想。下面是对一个通常的子数组A[p~r]进行快速排序的分治步骤：

① 分解：数组A[p~r]被划分为两个子数组A[p~q]和A[q+1~r]，使得A[q]大于等于A[p~q]中的每一个元素，且小于等于A[q+1~r]中的每一个元素。（须要说明的是，咱们容许A[p~q]和A[q+1~r]为空）

② 解决：对子数组A[p~q]和A[q+1~r]递归的调用快速排序。

③ 合并：由于子数组都是原址排序的，因此不须要合并操做，此时的A数组已是排好序的。

ps：所谓原址排序是指：咱们在对组进行排序的过程当中 只有常数个元素被存储到数组外面。

下面给出伪代码：

能够看出，算法的关键是partiton方法的实现。下面给出它的算法实现：

直接看可能以为很晕，咱们结合实例看看它是如何工做的：

    上图(a~i)表示的是对子数组A[p~r] =[2,8,7,1,3,5,6,4]进行排序时，每次迭代以前数组元素和一些变量的值。

    咱们能够初步看出，在i和j移动的过程当中，数组被分红了三个部分（分别用灰色，黑色，白色表示），其中i和j就是分割线，而且浅灰部分的元素均比A[r]小，黑色部分的元素均比A[r]大（(i)图除外，由于循环完毕以后执行了exchange A[i+1] with A[j]）。

    咱们再仔细分析一下具体细节：

    ① 首先看迭代以前的部分。它执行了x = A[r]，目的是把子数组A的最后一位做为一个“基准”，其余的全部元素都是和它进行比较。它在迭代过程当中值一直都没改变。而后执行i = p –基准 1，此时i在子数组A的左端。

    ② 再看迭代部分。迭代时j从子数组A的开头逐步移至A的倒数第二位。每次迭代中，会比较当前j位置的值和“基准”的大小，若是小于或相等“基准”，就将灰色部分的长度增长1（i=i+1），而后把j位置的值置换到灰色部分的末尾（exchange A[i] with A[j]）。这样迭代下来，就能保证灰色部分的值都比“基准”小或相等，而黑色部分的值都比“基准”大。

    ③ 最后看迭代完成后的部分。就进行了一步 exchange A[i+1] with A[j]操做，就是把“基准”置换到灰色部分与黑色部分之间的位置。

    这样全部的操做下来，就产生了一个“临界”位置q，使得A[q]大于等于A[p~q]中的每一个元素，而小于等于A[q+1~r]中的每一个元素。

    更严格的，咱们能够用之前介绍的循环不变式（见算法基础——算法导论(1)）来证实其正确性。但因为叙述起来比较麻烦，这里就不给出了。

    下面咱们给出快速排序(quick-sort)算法的Java实现代码：

public static void main(String[] args) {
	int[] array = { 9, 2, 4, 0, 4, 1, 3, 5 };
	quickSort(array, 0, array.length - 1);
	printArray(array);
}

/**
 * 快速排序
 * 
 * @param array
 *            待排序数组
 * @param start
 *            待排序子数组的起始索引
 * @param end
 *            待排序子数组的结束索引
 */
public static void quickSort(int[] array, int start, int end) {
	if (start < end) {
		int position = partition(array, start, end);
		quickSort(array, start, position - 1);
		quickSort(array, position + 1, end);
	}
}

/**
 * 重排array，并找出“临界”位置的索引
 * 
 * @param array
 *            待重排数组
 * @param start
 *            待重排子数组的起始索引
 * @param end
 *            待重排子数组的结束索引
 * @return
 */
public static int partition(int[] array, int start, int end) {
	int position = start - 1;
	int base = array[end];
	for (int i = start; i < end; i++) {
		if (array[i] <= base) {
			position++;
			int temp = array[position];
			array[position] = array[i];
			array[i] = temp;
		}
	}
	int temp = array[position + 1];
	array[position + 1] = array[end];
	array[end] = temp;
	return position + 1;
}

/**
 * 打印数组
 * 
 * @param array
 */
public static void printArray(int[] array) {
	for (int i : array) {
		System.out.print(i + "");
	}
	System.out.println();
}

结果：

2. 快速排序的性能

    快速排序的运行时间是跟划分密切相关的，由于划分影响着子问题的规模。

(1) 最坏状况划分

    当每次划分把问题分解为一个规模为n-1的问题和一个规模为0的问题时，快速排序将产生最坏的状况（之后给出这个结论的证实，目前能够想象的出）。因为划分操做的时间复杂度为θ(n)；当对一个长度为0的数组进行递归操做时，会直接返回，时间为T(0) = θ(1)。因而算法总运行时间的递归式为：

T(n) = T(n-1) + T(0) + θ(n) = T(n-1) + θ(n) 。

能够解得，T(n) = θ(n²)。

    因而可知，在划分都是最大程度不平均的状况下，快速排序算法的运行时间并不比插入排序好，甚至在某些状况下（好比数组自己已按大小排好序），不如插入排序。

 

 

(2) 最好状况划分

 

    当每次划分都是最平均的时候（即问题规模被划分为[n/2]和【n/2】-1时），快速排序性能很好，总运行时间的递归式为：

T(n) = 2T(n/2) + θ(n)

能够解得，T(n) = θ(nlg n)。

 

(3) 平均划分

    快速排序算法的平均运行时间，更接近于最好状况划分时间而非最坏状况划分时间。理解这一点的关键就是理解划分的平均性是如何反映到描述运行时间的递归式上的。

    咱们举个例子，对于一个9:1的划分，乍一看，这种划分是很不平均的。此时的运行时间递归式为：

T(n)  = T(9n/10) + T(n/10) + cn，

咱们能够用以下递归树来更加形象地描述运行时间：

递归会在深度为log10/9n = θ(lg n )处终止，所以，快速排序的总代价为O(nlgn)。可见，在直观上看起来很是不平均的划分，其运行时间是接近最好状况划分的时间的。事实上，对于任何一种常数比例的划分，其运行时间老是O(nlgn)。

 

3. 快速排序的随机化版本

    以上的讨论其实都作了一个前提的声明，输入数据的全部排列都是等几率的。可是事实上这个条件并不必定老是成立。正如之前介绍的，有时候咱们再在算法中引入随机性，可使得算法对因此的输入都有较好的指望性能。不少人都选择随机化版本的快速排序做为大数据输入状况下的排序算法。

    咱们可使用对数组的全部元素进行随机化排序的方式引入随机性。但为了简便，咱们这里采用一种叫作随机抽样(random sampling)的随机化技术。

    与以上始终采用A[r]做为“基准”的方法不一样的是，随机抽样是从子数组A[p~r]中随机的抽取一个元素，把它做为“基准”，并与A[r]交换。其余的过程与上面介绍的一致。

下面是随机化版本的算法描述：

 

下面给出随机化版本的Java实现代码：

public static void main(String[] args) {
	int[] array = { 9, 2, 4, 0, 4, 1, 3, 5 };
	randomizedQuickSort(array, 0, array.length - 1);
	printArray(array);
}

public static int randomPartition(int[] array, int start, int end) {
	int random = (int) (Math.random() * ((end - start) + 1)) + start;
	int temp = array[random];
	array[random] = array[end];
	array[end] = temp;
	return partition(array, start, end);
}

/**
 * 快速排序
 * 
 * @param array
 *            待排序数组
 * @param start
 *            待排序子数组的起始索引
 * @param end
 *            待排序子数组的结束索引
 */
public static void randomizedQuickSort(int[] array, int start, int end) {
	if (start < end) {
		int position = randomPartition(array, start, end);
		randomizedQuickSort(array, start, position - 1);
		randomizedQuickSort(array, position + 1, end);
	}
}

运行结果：

4. 快速排序分析

    在第2小节中咱们给出了快速排序性能的直观分析，以及它速度比较快的缘由。这一节咱们要给出一个更加严谨的分析。

(1) 最坏状况分析

   咱们用T(n)来表示规模为n的数组采用快速排序法排序所需的时间。PARTION函数生成的两个子数组的总长度是n-1，咱们设其中一个的长度为q（0 ≤ q ≤ n-1），那么另外一个的长度为n-q-1，所以有递归式：

咱们容易知道，上式中q在端点上取得最大值。由此咱们获得：

所以，T(n) = θ(n²) + θ(n) = θ(n²)；

这就是说，快速排序算法的最坏状况的运行时间是θ(n²)；

(2) 指望运行时间

    如今咱们要求，在平均状况下，快速排序的运行时间。所以咱们先对问题进行分析。

    从算法的描述中咱们能够看出，快速排序的运行时间是由在PARTITION操做上花费的时间决定的。每一次PARTITION操做都会从数组中挑选出一个数做为“基准”，所以PARTITION操做的总次数不会超过数组元素的总个数n。而每一次PARTITION操做的时间包括O(1)加上一段循环的时间。而在该循环的每次迭代中，都会比较“基准”元素与其余元素。所以，若是咱们能够统计出总的比较次数（注意这里所说的比较次数是整个快速排序过程当中比较的次数），就可以知道该循环的运行时间，从而就能给出快速排序的运行时间。

    为了便于分析，不失通常性，咱们将数组A的各个元素重命名为Z1，Z2，…Zn，其中Zi表示数组A中第i小的元素；此外咱们还定义Zij表示一个包含元素Zi到Zj（包括Zi和Zj）的集合，即Zij=｛Zi，Zi+1，…Zj｝。

    和几率分析和随机算法(2)——算法导论(6)中方式①介绍的方法同样，咱们引入一个指示器随机变量Xij来表示Zi与Zj是否进行了比较，即：

由于每一对元素至多被计较一次，所以咱们能够很容易算出总比较次数为：

对上式两边取指望得：

下面咱们来分析如何求P(zi与zj进行比较)。

    咱们先从一个简单的例子入手。考虑对一个包含数字1~10的数组A进行快速排序的状况。假设咱们第一次进行PARTITION操做时，选定的“基准”元素是7，那么数组A将被划分为｛1,2,3,4,5,6｝和｛8,9,10｝两个数组，咱们能够发现，这两个数组中彼此任何两个元素是不会相互比较的。所以，咱们有以下断言：若是一个知足zi < X < zj（假设各元素互异）的元素x被选为“基准”后，zi 和zj就不会被比较了；若是zi在Zij的其余元素以前被选为“基准”，那么zi会与Zij中的其余全部元素进行比较。因而，咱们有：

进而获得：

由此咱们能够得出结论：使用RANDOMIZED-PARTITION，在输入元素互异的状况下，快速排序算法的指望运行时间是O(nlgn)。