数据结构与算法——快速排序

本专栏是学习王争老师的《数据结构与算法之美》的学习总结，详细内容可以去学习王争老师的专栏，希望大家都能够有所收获。同时也欢迎大家能够与我一起交流探讨！

快速排序（Quicksort）

快速排序利用分治算法，主要的思想为：如果要排序数组中下标从 p 到 r 之间的一组数据，选择 p 到 r 之间的任意一个数据作为 pivot（分区点）。

遍历 p 到 r 之间的数据，将小于 pivot 的放到左边，将大于 pivot 的放到右边，将 pivot 放到中间。经过这一步骤之后，数组 p 到 r 之间的数据就被分成三部分，前面 p 到 q - 1 之间都是小于pivot的，中间是 pivot，后面的 q + 1 到 r 之间是大于 pivot 的。

使用递推公式描述上述过程：

递推公式：
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1… r)

终止条件：
p >= r

递归公式转换成递归代码，如下Java代码所示：

 // 快速排序递归函数，p,r为下标
 private static void quickSortInternally(int[] a, int p, int r) {
   if (p >= r) return;

   int q = partition(a, p, r); // 获取分区点
   quickSortInternally(a, p, q-1);
   quickSortInternally(a, q+1, r);
 }

伪代码如下所示：

// 快速排序，A是数组，n表示数组的大小
quick_sort(A, n) {
  quick_sort_c(A, 0, n-1)
}
// 快速排序递归函数，p,r为下标
quick_sort_c(A, p, r) {
  if p >= r then return
  
  q = partition(A, p, r) // 获取分区点
  quick_sort_c(A, p, q-1)
  quick_sort_c(A, q+1, r)
}

归并排序中有一个merge()合并函数，而在快速排序中有一个partition()分区函数。partition()就是随机选择一个元素作为 pivot（一般清下，可以选择 p 到 r区间的最后一个元素），然后对A[p…r]分区，函数返回 pivot 的下标。

如果希望快排是原地排序算法，则它的空间复杂度为O(1)，则 partition() 分区函数就不能占用太多额外的内存空间，就需要在 A[p…r]的原地完成分区操作。

原地分区函数的实现如下Java代码所示：

private static int partition(int[] a, int p, int r) {
  int pivot = a[r];
  int i = p;
  for(int j = p; j < r; ++j) {
    if (a[j] < pivot) {
      if (i == j) {
        ++i;
      } else {
        int tmp = a[i];
        a[i++] = a[j];
        a[j] = tmp;
      }
    }
  }

  int tmp = a[i];
  a[i] = a[r];
  a[r] = tmp;

  System.out.println("i=" + i);
  return i;
}

伪代码如下所示：

partition(A, p, r) {
  pivot := A[r]
  i := p
  for j := p to r-1 do {
    if A[j] < pivot {
      swap A[i] with A[j]
      i := i+1
    }
  }
  swap A[i] with A[r]
  return i

上述代码中，通过游标 i 把 A[p…r-1]分成两部分。A[p…i-1]的元素都是小于 pivot 的，暂且叫它“已处理区间”，A[i…r-1]是“未处理区间”。

每次都从未处理的区间 A[i…r-1]中取一个元素 A[j]，与 pivot 对比，如果小于 pivot，则将其加入到已处理区间的尾部，也就是 A[i]的位置。

上述分区的过程设计交换操作，如果数组有两个相同的元素，例如序列6，8，7，6，3，5，9，4，在经过第一次分区操作之后，两个 6 的相对先后顺序就会改变。所以，快速排序并不是一个稳定的排序算法。

快速排序与归并排序的区别

快排和归并用的都是分治思想，递推公式和递归代码也非常相似，那它们的区别在哪里呢？

由上图可以发现，归并排序的处理过程是由下到上的，先处理子问题，然后再合并。而快排正好相反，它的处理过程是由上到下，先分区，然后再处理子问题。

归并排序虽然是稳定的、时间复杂度为 O(nlogn) 的排序算法，但是它是非原地排序算法。归并之所以是非原地排序算法，主要原因是合并函数无法在原地执行。快速排序通过设计巧妙的原地分区函数，可以实现原地排序，解决了归并排序占用太多内存的问题。

快速排序的性能分析

快排是一种原地、不稳定的排序算法。即在一个数组中存在相同元素时，快速排序可能会修改相同元素的顺序，并且快速排序不需要额外的临时空间进行排序，空间复杂度为O(1)。

快速排序也是通过递归实现，对于递归代码的时间复杂度，总结的公式如下：

T(1) = C；   n=1时，只需要常量级的执行时间，所以表示为C。
T(n) = 2*T(n/2) + n； n>1

如果每次分区操作都能正好把数组分成大小接近相等的两个小区间，那么快排的时间复杂度递推求解公式与归并算法相同，因此，快排的时间复杂度也为O(nlogn)。

但是，公式成立的前提是每次分区操作，选择的 pivot 都很合适，正好能将大区间对等地一分为二。但实际上这种情况是很难实现的。

两种极端情况下的时间复杂度，一个是分区极其均衡，一个是分区极其不均衡。分别对应着快速排序的最好情况时间复杂度和最坏情况时间复杂度。

快排的平均时间复杂度，假设每次分区操作都将区间分成大小为 9:1 的两个小区间。套用递归时间复杂度的递推公式则有：

T(1) = C；   n=1时，只需要常量级的执行时间，所以表示为C。
T(n) = T(n/10) + T(9*n/10) + n； n>1

T(n) 在大部分情况下的时间复杂度都可以做到 O(nlogn)，只有在极端情况下，才会退化到 O(n^2)。而且，有许多的方法可以将这个概率降到很低。

实际应用场景

**O(n) 时间复杂度内求无序数组中的第 K 大元素。**比如，4， 2， 5， 12， 3 这样一组数据，第 3 大元素就是 4。

选择数组区间 A[0…n-1]的最后一个元素 A[n-1]作为 pivot，对数组 A[0…n-1]原地分区，这样数组就分成了三部分，A[0…p-1]、A[p]、A[p+1…n-1]。

• 如果 p+1=K，那 A[p]就是要求解的元素；
• 如果 K>p+1, 说明第 K 大元素出现在 A[p+1…n-1]区间，再按照上面的思路递归地在 A[p+1…n-1]这个区间内查找。
• 如果K < p + 1，就可以在A[0…p-1]区间查找。

为什么上述解决思路的时间复杂度是 O(n)？

• 第一次分区查找，需要对大小为 n 的数组执行分区操作，需要遍历 n 个元素。
• 第二次分区查找，只需要对大小为 n/2 的数组执行分区操作，需要遍历 n/2 个元素。
• 依次类推，分区遍历元素的个数分别为、n/2、n/4、n/8、n/16.……直到区间缩小为 1。

把每次分区遍历的元素个数加起来，就是：n+n/2+n/4+n/8+…+1。这是一个等比数列求和，最后的和等于 2n-1。所以，上述解决思路的时间复杂度就为 O(n)。

总结

1、归并排序与快速排序使用的都是分治的思想，代码通过递归实现。

• 理解归并排序的重点是理解递推公式和 merge() 合并函数。
• 理解快排的重点也是理解递推公式和partition() 分区函数。

2、归并排序算法是一种在任何情况下时间复杂度都比较稳定的排序算法，但也存在致命的缺点，即归并排序并不是原地排序算法，空间复杂度比较高，是O(n)，因此并没有快排应用广泛。

3、快速排序算法虽然最坏情况下的时间复杂度是O(n²)，但平均情况下时间复杂度都是O(nlogn)。不仅如此，快速排序算法时间复杂度退化到 O(n²) 的概率非常小，可以通过合理地选择 pivot 来避免这种情况。