《算法图解》学习笔记(四):分而治之和快速排序(附代码)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/TeFuirnever/article/details/100564929

python学习之路 - 从入门到精通到大师

一、分而治之

《算法图解》学习笔记(三):递归和栈(附代码) 深入介绍了递归。我们将探索 分而治之(divide and conquer,D&C) —— 一种著名的递归式问题解决方法。只能解决一种问题的算法毕竟用处有限,而D&C提供了解决问题的思路,是另一个可供使用的工具。面对新问题时,你不再束手无策,而是自问:“使用分而治之能解决吗?”

D&C好像很不错,那我们就一直用这个方法好了,然而它并不那么容易掌握,先来看示例。

1)例子一

假设你是农场主,有一小块土地(其实面积也不小了,168 x 64 = 10752 m2m^2)。
在这里插入图片描述
你要将这块地均匀地分成方块,且分出的方块要尽可能大。一共有下面三种方法:
在这里插入图片描述
显然,上面的分法都不符合要求。那么如何将一块地均匀地分成方块,并确保分出的方块是最大的呢?

答案是使用D&C策略!D&C算法是递归的。使用D&C解决问题的过程包括两个步骤:

  1. 找出基线条件,这种条件必须尽可能简单。
  2. 不断将问题分解(或者说缩小规模),直到符合基线条件。

下面就来使用D&C来找出前述问题的解决方案,可你能使用的最大方块有多大呢?

首先,找出基线条件。《算法图解》学习笔记(三):递归和栈(附代码) 中我们提到过,基线条件很重要!!!
在这里插入图片描述
最容易处理的情况是,一条边的长度是另一条边的整数倍。
在这里插入图片描述
如果一边长25 m,另一边长50 m,那么可使用的最大方块为 25 m × 25 m。换言之,可以将这块地分成两个这样的方块。

现在需要找出 递归条件,这正是D&C的用武之地。

定义:所谓 分而治之 就是把一个复杂的算法问题按一定的“分解”方法分为等价的规模较小的若干部分,然后逐个解决,分别找出各部分的解,把各部分的解组成整个问题的解,这种朴素的思想来源于人们生活与工作的经验,也完全适合于技术领域。诸如软件的体系结构设计、模块化设计都是分而治之的具体表现。

根据D&C的定义,每次递归调用都必须缩小问题的规模。如何缩小前述问题的规模呢?我们首先找出这块地可容纳的最大方块。
在这里插入图片描述
你可以从这块地中划出两个640 m × 640 m的方块,同时余下一小块地。现在是顿悟时刻:何不对余下的那一小块地使用相同的算法呢?
在这里插入图片描述
最初要划分的土地尺寸为1680 m × 640 m,而现在要划分的土地更小,为640 m × 400 m。适用于这小块地的最大方块,也是适用于整块地的最大方块。换言之,你将均匀划分1680 m × 640 m土地的问题,简化成了均匀划分640 m × 400 m土地的问题!

下面再次使用同样的算法。对于640 m × 400 m的土地,可从中划出的最大方块为400 m × 400 m。
在这里插入图片描述
这将余下一块更小的土地,其尺寸为400 m × 240 m。
在这里插入图片描述
你可从这块土地中划出最大的方块,余下一块更小的土地,其尺寸为240 m × 160 m。
在这里插入图片描述
接下来,从这块土地中划出最大的方块,余下一块更小的土地。
在这里插入图片描述
余下的这块土地满足基线条件,因为160 是80 的整数倍。将这块土地分成两个方块后,将不会余下任何土地!
在这里插入图片描述
因此,对于最初的那片土地,适用的最大方块为80 m × 80 m。
在这里插入图片描述
这里重申一下D&C的工作原理:

  1. 找出简单的基线条件;
  2. 确定如何缩小问题的规模,使其符合基线条件。

D&C并非可用于解决问题的算法,而是一种解决问题的思路。

2)例子二

我们再来看一个例子。给定一个数字数组:
在这里插入图片描述
你需要将这些数字相加,并返回结果。使用循环很容易完成这种任务。

def sum(arr):
  total = 0
  for x in arr:
  	total += x
  return total

print(sum([1, 2, 3, 4]))

在这里插入图片描述
但如何使用递归函数来完成这种任务呢?

第一步:找出基线条件。最简单的数组什么样呢?请想想这个问题,再接着往下读。如果数组不包含任何元素或只包含一个元素,计算总和将非常容易。
在这里插入图片描述
因此这就是基线条件。

第二步:每次递归调用都必须离空数组更近一步。如何缩小问题的规模呢?下面是一种办法。
在这里插入图片描述
这与下面的版本等效。
在这里插入图片描述
这两个版本的结果都为12,但在第二个版本中,给函数sum传递的数组更短。换言之,这缩小了问题的规模!

函数sum的工作原理类似于下面这样。
在这里插入图片描述
这个函数的运行过程如下。
在这里插入图片描述
别忘了,递归记录了状态。
在这里插入图片描述

编写涉及数组的递归函数时,基线条件通常是数组为空或只包含一个元素。陷入困境时,请检查基线条件是不是这样的。

二、快速排序

快速排序是一种常用的排序算法,比选择排序快得多。例如,C语言标准库中的函数qsort实现的就是快速排序。快速排序也使用了D&C。

快速排序的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

下面来使用快速排序对数组进行排序。对排序算法来说,最简单的数组什么样呢?就是根本不需要排序的数组。
在这里插入图片描述
因此,基线条件为数组为空或只包含一个元素。在这种情况下,只需原样返回数组——根本就不用排序。

def quicksort(array):
	if len(array) < 2:
		return array

我们来看看更长的数组。对包含两个元素的数组进行排序也很容易。
在这里插入图片描述
包含三个元素的数组呢?
在这里插入图片描述
别忘了,你要使用D&C,因此需要将数组分解,直到满足基线条件。下面介绍快速排序的工作原理。首先,从数组中选择一个元素,这个元素被称为基准值(pivot)。

稍后再介绍如何选择合适的基准值。我们暂时将数组的第一个元素用作基准值。
在这里插入图片描述
接下来,找出比基准值小的元素以及比基准值大的元素。
在这里插入图片描述
这被称为 分区(partitioning)。现在你有

  • 一个由所有小于基准值的数字组成的子数组;
  • 基准值;
  • 一个由所有大于基准值的数组组成的子数组。

这里只是进行了分区,得到的两个子数组是无序的。但如果这两个数组是有序的,对整个数组进行排序将非常容易。
在这里插入图片描述
如果子数组是有序的,就可以像下面这样合并得到一个有序的数组:左边的数组 + 基准值 + 右边的数组

在这里,就是 [10, 15] + [33] + [],结果为有序数组[10, 15, 33]。

如何对子数组进行排序呢?对于包含两个元素的数组(左边的子数组)以及空数组(右边的子数组),快速排序知道如何将它们排序,因此只要对这两个子数组进行快速排序,再合并结果,就能得到一个有序数组!
在这里插入图片描述
不管将哪个元素用作基准值,这都管用。假设你将15用作基准值。
在这里插入图片描述
这个子数组都只有一个元素,而你知道如何对这些数组进行排序。现在你就知道如何对包含三个元素的数组进行排序了,步骤如下:

  1. 选择基准值。
  2. 将数组分成两个子数组:小于基准值的元素和大于基准值的元素。
  3. 对这两个子数组进行快速排序。

包含四个元素的数组呢?
在这里插入图片描述
假设你也将33用作基准值。
在这里插入图片描述
左边的子数组包含三个元素,而你知道如何对包含三个元素的数组进行排序:对其递归地调用快速排序。
在这里插入图片描述
因此你能够对包含四个元素的数组进行排序。如果能够对包含四个元素的数组进行排序,就能对包含五个元素的数组进行排序。为什么呢?假设有下面这样一个包含五个元素的数组。
在这里插入图片描述
根据选择的基准值,对这个数组进行分区的各种可能方式如下。
在这里插入图片描述
注意,这些子数组包含的元素数都在0~4内,而你已经知道如何使用快速排序对包含0~4个元素的数组进行排序!因此,不管如何选择基准值,你都可对划分得到的两个子数组递归地进行快速排序。

例如,假设你将3用作基准值,可对得到的子数组进行快速排序。
在这里插入图片描述
将子数组排序后,将它们合并,得到一个有序数组。即便你将5用作基准值,这也可行。
在这里插入图片描述
将任何元素用作基准值都可行,因此你能够对包含五个元素的数组进行排序。同理,你能够对包含六个元素的数组进行排序,以此类推。

归纳证明
刚才我们使用的就是归纳证明!归纳证明是一种证明算法行之有效的方式,它分两步:基线条件和归纳条件。是不是有点似曾相识的感觉?例如,假设我要证明我能爬到梯子的最上面。递归条件是这样的:如果我站在一个横档上,就能将脚放到下一个横档上。换言之,如果我站在第二个横档上,就能爬到第三个横档。这就是归纳条件。而基线条件是这样的,即我已经站在第一个横档上。因此,通过每次爬一个横档,我就能爬到梯子最顶端。
在这里插入图片描述

对于快速排序,可使用类似的推理。在基线条件中,证明这种算法对空数组或包含一个元素的数组管用。在归纳条件中,证明如果快速排序对包含一个元素的数组管用,对包含两个元素的数组也将管用;如果它对包含两个元素的数组管用,对包含三个元素的数组也将管用,以此类推。因此可以说,快速排序对任何长度的数组都管用。

下面是快速排序的代码。

python版本代码如下:

def quicksort(array):
  if len(array) < 2:
    #基本情况下,具有0或1个元素的数组是已经“排序”的
    return array
  else:
    #递归情况
    pivot = array[0]
    #小于基准值的所有元素的子数组
    less = [i for i in array[1:] if i <= pivot]
    #大于基准值的所有元素的子数组
    greater = [i for i in array[1:] if i > pivot]
    return quicksort(less) + [pivot] + quicksort(greater)

print(quicksort([10, 5, 2, 3]))

在这里插入图片描述
c++版本代码如下:

#include <iostream>
#include <vector>

using std::cout;
using std::endl;

template <typename T>
std::vector<T> quicksort(const std::vector<T>& arr) {
    // base case, arrays with 0 or 1 element are already "sorted"
    if (arr.size() < 2) 
        return arr;
    
    // recursive case
    const T* pivot = &arr.front() + arr.size() / 2 - 1; // set the pivot somewhere in the middle
    std::vector<T> less;  // vector to store all the elements less than the pivot
    std::vector<T> greater;  // vector to store all the elements greater than the pivot

    for (const T* item = &arr.front(); item <= &arr.back(); item++) {
        if (item == pivot) continue; // skip pivot element
        if (*item <= *pivot) less.push_back(*item);
        else greater.push_back(*item);
    }
    
    std::vector<T> sorted_less = quicksort(less);
    std::vector<T> sorted_greater = quicksort(greater);
    // concatenate less part, pivot and greater part
    sorted_less.push_back(*pivot);
    sorted_less.insert(sorted_less.end(), sorted_greater.begin(), sorted_greater.end());
    
    return sorted_less;
}

int main() {
    std::vector<int> arr = {10, 5, 2, 3};
    std::vector<int> sorted = quicksort(arr);
    for (int num : sorted) {
        cout << num << " ";
    }
    cout << endl;
}

三、再谈大O 表示法

快速排序的独特之处在于,其速度取决于选择的基准值。在讨论快速排序的运行时间前,我们再来看看最常见的大O运行时间。
在这里插入图片描述
上述图表中的时间是基于每秒执行10次操作计算得到的。这些数据并不准确,这里提供它们只是想让你对这些运行时间的差别有大致认识。实际上,计算机每秒执行的操作远不止10次。

对于每种运行时间,本书还列出了相关的算法。来看看第2章介绍的选择排序,《算法图解》学习笔记(二):选择排序(附代码),其运行时间为O(n2),速度非常慢。

还有一种名为 合并排序(merge sort) 的排序算法,其运行时间为O(n log n),比选择排序快得多!快速排序的情况比较棘手,在最糟情况下,其运行时间为O(n2)。与选择排序一样慢!但这是最糟情况。在平均情况下,快速排序的运行时间为O(n log n)。你可能会有如下疑问。

  • 这里说的最糟情况和平均情况是什么意思呢?
  • 若快速排序在平均情况下的运行时间为O(n log n),而合并排序的运行时间总是O(n log n),为何不使用合并排序?它不是更快吗?

带着疑问,接着看下去,,,

1)比较合并排序和快速排序

假设有下面这样打印列表中每个元素的简单函数。

def print_items(list):
	for item in list:
		print(item)

这个函数遍历列表中的每个元素并将其打印出来。它迭代整个列表一次,因此运行时间为O(n)。现在假设你对这个函数进行修改,使其在打印每个元素前都休眠1秒钟。

from time import sleep
def print_items2(list):
	for item in list:
		sleep(1)
		print(item)

它在打印每个元素前都暂停1秒钟。假设你使用这两个函数来打印一个包含5个元素的列表。
在这里插入图片描述
这两个函数都迭代整个列表一次,因此它们的运行时间都为O(n)。你认为哪个函数的速度更快呢?我认为 print_items 要快得多,因为它没有在每次打印元素前都暂停1秒钟。因此,虽然使用大O表示法表示时,这两个函数的速度相同,但实际上 print_items 的速度更快。在大O表示法O(n)中,n实际上指的是这样的。
在这里插入图片描述
c 是算法所需的固定时间量,被称为常量。例如,print_ items 所需的时间可能是10毫秒 * n,而 print_items2 所需的时间为1秒 * n

通常不考虑这个常量,因为如果两种算法的大O运行时间不同,这种常量将无关紧要。就拿二分查找简单查找来举例说明。假设这两种算法的运行时间包含如下常量。
在这里插入图片描述
你可能认为,简单查找的常量为10毫秒,而二分查找的常量为1秒,因此简单查找的速度要快得多。现在假设你要在包含40亿个元素的列表中查找,所需时间将如下。
在这里插入图片描述
正如你看到的,二分查找的速度还是快得多,常量根本没有什么影响。

但有时候,常量的影响可能很大,对快速查找合并查找来说就是如此。快速查找的常量比合并查找小,因此如果它们的运行时间都为O(n log n),快速查找的速度将更快。实际上,快速查找的速度确实更快,因为相对于遇上最糟情况,它遇上平均情况的可能性要大得多。

此时你可能会问,何为平均情况,何为最糟情况呢?

2)平均情况和最糟情况

快速排序的性能高度依赖于你选择的基准值。假设你总是将第一个元素用作基准值,且要处理的数组是有序的。由于快速排序算法不检查输入数组是否有序,因此它依然尝试对其进行排序。
在这里插入图片描述
注意,数组并没有被分成两半,相反,其中一个子数组始终为空,这导致调用栈非常长。现在假设你总是将中间的元素用作基准值,在这种情况下,调用栈如下。
在这里插入图片描述
调用栈短得多!因为你每次都将数组分成两半,所以不需要那么多递归调用。你很快就到达了基线条件,因此调用栈短得多。

第一个示例展示的是最糟情况,而第二个示例展示的是最佳情况。在最糟情况下,栈长为O(n),而在最佳情况下,栈长为O(log n)。

现在来看看栈的第一层。你将一个元素用作基准值,并将其他的元素划分到两个子数组中。这涉及数组中的全部8个元素,因此该操作的时间为O(n)。在调用栈的第一层,涉及全部8个元素,但实际上,在调用栈的每层都涉及O(n)个元素。
在这里插入图片描述
即便以不同的方式划分数组,每次也将涉及O(n)个元素。
在这里插入图片描述
因此,完成每层所需的时间都为O(n)。
在这里插入图片描述
在这个示例中,层数为O(log n)(用技术术语说,调用栈的高度为O(log n)),而每层需要的时间为O(n)。因此整个算法需要的时间为O(n) * O(log n) = O(n log n)。这就是最佳情况。

在最糟情况下,有O(n)层,因此该算法的运行时间为O(n) * O(n) = O(n2)。

知道吗?这里要告诉你的是,最佳情况也是平均情况。只要你每次都随机地选择一个数组元素作为基准值,快速排序的平均运行时间就将为O(n log n)。快速排序是最快的排序算法之一,也是D&C典范。

四、总结

  • D&C将问题逐步分解。使用D&C处理列表时,基线条件很可能是空数组或只包含一个元素的数组。
  • 实现快速排序时,请随机地选择用作基准值的元素。快速排序的平均运行时间为O(n log n)。
  • 大O表示法中的常量有时候事关重大,这就是快速排序比合并排序快的原因所在。
  • 比较简单查找和二分查找时,常量几乎无关紧要,因为列表很长时,O(log n)的速度比O(n)快得多。

参考文章

文章创建于: 2019-09-05 18:59:50
展开阅读全文

没有更多推荐了,返回首页