《算法导论》第二章 算法基础 个人心得——从插入排序到初识分治法

算法基础

写在前面的废话 ：

1. 这是我基于算法导论（第三版）这本书写的第一篇心得。我写博客完全是随缘的状态，想写什么写什么。正好最近开始看《算法导论》，于是就以此书为基础，将在我学习过程中的所见所闻、心得体会写在博客之中。一方面为同样在学习这本书的人提供一个参考，另一方面也让我自己可以清楚的梳理脉络，提高学习效率——个人认为，学习的最有效率的方法是讲出来。当你能给别人讲明白时，说明自己也明白了。为什么不从第一章开始写？？？因为第一章主要是概念类的东西，看看就好，此处不赘述。

2. 《算法导论》还是《算法（第四版）》？？？

   

   这两本书都是写算法的神书，两个没有必要都学。之前也纠结过一段时间，综合了网上的各种评价，《算法导论》数学证明比较多，偏学术；《算法》重点在于工程应用。对于编程者来说，直接用《算法》就可以了。对于我来说，由于我在读研究生，因此多了解一些算法中的数学思想是很有帮助的，因此我选算法导论。当然，你要是看到了这里，说明你也大概率学了算法导论。要是两个都学的请收下我的膝盖，或许我会在学完这本书之后有时间啃一啃另外一本，现在应该没什么机会。

3. 我在学习算法导论前的知识基础：虽然刚开始学，但是我之前大致翻了一下，这本书里面的一些数学论证用到了高等数学的知识。此外对于栈、队列、图之类的数据结构基础讲的没那么细。因此，《算法导论》这本书，上来就让你啃，你肯定会觉得难，学着学着就慢慢就放弃了学习的信心。所以在学习算法导论之前，应该先看看一些预备知识的书。首先，大学的高数、线代、概率论要好好学学，不仅对这本书，对于别的方向也有很大作用。此外，我之前学习了《数据结构》（清华大学严蔚敏版本），和《算法图解》。《数据结构》是官方教材，是我在考研时学的。由于当时我本科并不是计算机专业，而要跨考计算机研究生，所以学起来很吃力。而《算法图解》就容易的多了。我由于有了数据结构的底子（其实也没多少，学得不好QAQ），以及当时正在学python，所以对于这本书我学起来还是很容易的（其实没有基础学起来也不费劲）。《算法图解》通俗易懂，把算法的一些概念方法用生活中通俗的例子以图画的形式来表达，更容易引起学习兴趣。对于代码方面也有一定底子，像C、Python等。当然这些都没看过，想要硬看这本书也不是不可能，有人也成功过。但是我觉得，磨刀不误砍柴工，有了知识储备，你能学习的更好，对于一些知识理解的也会更快更深刻。

4. 我不是什么大牛，只是刚起步的新人。刚开始学习，难免有错误之处，恳请批评指正，大家一同进步，一同提高。

下面，正文开始。

在这一章当中，首先给出了一个排序方法——插入排序，用该方法来引入‘’循环不变式‘’这一思想，说明如何证明算法正确并作为例子分析运行时间。然后，引出算法中一个非常重要的方法——分治法，同时，利用分治法的思想，开发出归并排序，并进行分析。

一、插入排序

首先了解一下什么是插入排序：插入排序是一种排序方法，指在待排序的序列<a1,a2,…an>中，假设前面i-1(其中i>=2)个数已经是排好顺序的，现将第i个数插到前面已经排好的序列中，然后按照要求（升序或降序）找到合适自己的位置，使得插入第i个数的这个序列也是排好顺序的，按照此法对所有元素进行插入，直到整个序列排为有序的过程。最终输出为<a1’,a2’,…an’>，满足a1’≤a2’≤…≤an’(或a1’≥a2’≥…≥an’)。其中，希望被排序的数成为关键字。由于i>=2，所以一般关键字于第二位开始依次向后。

插入排序的工作方法如下图：

严格来讲图中所谓的“空位置”其实并不空。按照代码，在插入之前以前的数字仍然存在，“插入”只是用关键字覆盖原来数字。但是为了便于理解，在此将移动后的位置看作为“空位置”。同时，对于第一步，你也可以把索引为0的单独一个数看成有序。
工作原理搞清楚了，接下来是代码。由于原书给的是伪代码，这里就不展示了。在此基础上我用Python3写了个代码。

array = [5,2,4,6,1,3]
length = len(array)                             #数列长度
#升序排列
for j in range(1,length):                       #从第二个到最后一个迭代
    key = array[j]                              #选为关键字
    i = j-1                                     #从关键字的前一个开始
    while i>=0 and array[i]>key:                #与关键字比较，且限制在数列内                          
        array[i+1] = array[i]                   #大于关键字，将该数字向后移动（前后对调）
        i-=1                                    #继续判断前一个与关键字的大小关系
    array[i+1] = key                            #将关键字插入空位置，
    print(array)

#降序排列
for i in range(1,length):
    key = array[i]
    j = i-1
    while j>=0 and array[j]<key:                #原理相同，判定条件更改
        array[j+1] = array[j]
        j-=1
    array[j+1] = key
    print(array)

以上代码可以用列表解析等继续优化，或者是改为手动输入序列以及封装函数，有兴趣可以进一步探讨。
而在插入排序的过程中，我们注意到，在算法每次循环后，前n个数一定是排好顺序的（n为循环次数），即在算法的循环过程中总是存在一个维持不变的特性，这个特性一直保持到循环结束乃至算法结束。这就引出了一种思想，我们称为循环不变式。

二、循环不变式

当然，以上是我个人理解。书中对于循环不变式的概念给的很模糊。看了很多这方面的文章，不同作者理解的角度也不同。我们重点是知道循环不变式用来帮助理解算法的正确性。关于循环不变式，我们必须证明三条性质：
初始化：循环的第一次迭代之前，它为真。
保持：如果循环的某次迭代之前它为真，那么下次迭代之前它仍为真。
终止：在循环终止时，不变式为我们提供一个有用的性质，该性质有助于证明算法是正确的。
循环不变式类似于我们在数学中学过的数学归纳法，我们来复习一下：

最简单和常见的数学归纳法是证明当n等于任意一个自然数时某命题成立。证明分下面两步：
证明当n= 1时命题成立。
假设n=m时命题成立，那么可以推导出在n=m+1时命题也成立。（m代表任意自然数）
这种方法的原理在于：首先证明在某个起点值时命题成立，然后证明从一个值到下一个值的过程有效。当这两点都已经证明，那么任意值都可以通过反复使用这个方法推导出来。

而循环不变式的前两条性质正对应于数学归纳法的两步。首先证明一个基本情况成立，其次证明一个归纳步成立。
循环不变式的第三个性质应该是最重要的，也是他区别于数学归纳法的一点。在数学归纳法中，归纳步基本要无限的使用，因此没有终止。而在算法中，一般不能无限的循环下去，必须要有终止步。当循环终止时，停止“归纳”。

让我们以插入排序为例，看看如何证明这些性质成立。
初始化：首先证明在第一次循环迭代之前，循环不变式成立。对于A=[0,1,2,…,n-1]，在第一次循环之前，即下标j=1时，子数组 A[0,…,j-1] 仅由单个元素 A[0] 组成，该子数组是有序的（显然有序），其中，A[j] 为关键字（这里是 A[2] ）。这表明第一次循环之前循环不变式成立。
保持：其次证明第二条性质，证明每次迭代保持循环不变式。for循环内从关键字左边第一个开始，将 A[j-1] 、A[j-2] 、A[j-3] 等依次向右移动一个位置，直到A[j]找到合适位置，把A[j]插入到该位置。而这时子数组A[0…j]仍然由原来的A[0…j]中的元素组成，但已按序排列。因此，对for循环的下一次迭代增加j将保持循环不变式。
终止：下面看看循环终止条件：j>A.length-1=n-1。因为每次循环j都会+1，那么最终必有 j=n。将j用 n代替，即 A[0…j-1] 变为 A[0…n-1]（为什么是 A[0…j-1] 而不是 A[0…j]？因为每次迭代关键字都是j，在循环迭代之前即前j-1个数，故是 A[0…j-1]。），得到：子数组 A[0…n-1] 由原来的 A[0…n-1] 中的元素组成,但已有序。由于 A[0…n-1] 就是整个数组，所以整个数组已排序。因此算法正确。

三、分析算法

当一个算法设计好之后，我们要进行算法的分析。分析算法的作用是预测算法所需要的资源。在这里我们主要指的是计算时间。分析算法必须有一个要使用的实现技术的模型。同时，我们想要一种书写和处理都比较简单的表示方法，而且能表明算法资源需求的重要特征。

一般来说，算法需要的时间和输入规模呈正相关——规模越大，所需要的时间越多。“输入规模”在不同问题中的定义也不同，最自然的度量是输入中的项数。“运行时间"指的是执行的基本操作数或步数。下面，以插入排序为例，分析一下算法运行时间。在这里，我们假设第 i 行每次执行需要代价 Ci。首先我们给出插入排序核心部分中每条语句执行时间和次数，其中 n =A的长度(A.length)，tj 表示对 j 执行while循环的次数，取值为1~j。for或while循环退出时，执行头部测试的次数比循环体次数多1。我们可以得到：

该算法运行时间是每条语句运行时间之和。每条语句运行时间是代价×次数。总运行时间为：

当然，以上只是普遍情况下插入排序算法所需要的时间。若输入数组已经排好序，则出现最佳情况。这时，对每个 j=1，2…，n-1，在while判定时，当 i 取初始值 j-1 时，都有 A[j]<=key。对任意 j ，有 tj=1。故最佳运行时间为：
T(n)=C1n+C2(n-1)+C3(n-1)+C4(n-1)+C7(n-1) = (C1+C2+C3+C4+C7)n-(C2+C3+C7)
可表示为an+b，为n的线性函数。

若输入的数组反向排序，即递减序，则出现最坏情况。我们必须将每个元素 A[j] 与整个子数组 A[0…j-1]中的每个元素进行比较。所以对于 j=1,2,3…,n-1,有 tj=j。注意到：

在最坏情况下，插入排序运行时间为：T(n)=C1n+C2(n-1)+C3(n-1)+C4(n(n+1)/2-1)+C5(n(n-1)/2)+C6(n(n-1)/2)+C7(n-1) = (C4/2+C5/2+C6/2)n²+(C1+C2+C3+C4/2-C5/2-C6/2+C7)n-(C2+C3+C4+C7)
最坏时间可以表示为an²+bn+c，他是n的二次函数。

由于1、算法最坏时间给出了算法运行时间的上界，确保了算法不会超过这个界限；2、而且对于某些算法，最坏时间经常出现(比如对缺失信息的检索，每次都需要检索全部信息才能得出信息缺失的结论，即每次都是最坏情况)；3、平均情况往往与最坏情况一样坏。(在插入排序中，按照平均情况，在子数组 A[0…j-1] 的一半处插入关键字A[j]，这使得 tj 大约为 j/2 ，导致平均情况运行时间也是输入规模的二次函数)，所以我们往往集中于只求最坏情况运行时间。

显然，运行时间越少，证明算法越有效率。我们就自然想到了，如何比较运行时间，以考察算法的效率？
通过前面，我们可以看到，插入排序的最坏时间可以表示为an²+bn+c，其中a、b、c依赖于 ci。对于这个式子来说，存在这么多项，在比较的时候显然很麻烦，为了既能简便理解运行所需要的时间，又不过多舍弃掉有用的内容，我们做出一种抽象：运行时间的增长率或增长量级。通过考虑公式中最重要的项(an²)来确定增长量级。因为当n的数很大时，二次项的增长速度远远高于其他低阶项，使其他低阶项看起来并不重要了。同时我们也忽略常数系数，因为对于大的输入，常数系数的影响也不如增长率重要。最后，只剩下了n²，我们记为θ（n²）。如果一个算法最坏情况下运行时间比另一个算法更低的增长量级，则我们说前者比后者更有效。例如，θ（n²）比θ（n³）更有效。

增长量级的提出使得我们进一步思考：如何减少算法的增长量级，使其更有效？以排序算法为例，如何设计算法，使得新的排序算法比插入排序有更低的增长量级？为此，我们提出一种将问题分而治之的方法——分治法。

四、简介分治法

分治法，顾名思义，将原问题分解为几个较小规模的子问题，通过解决子问题，再合并子问题的解，最终求出原问题。在结构上以递归为典型：为了解决给定问题，算法多次调用自身以解决相关的子问题。分治法在每层递归时都有三个步骤：
分解：原问题分解为若干子问题，这些子问题是原问题较小规模的实例。
解决：解决这些子问题，递归求解各子问题，若子问题规模足够小，则直接求解。
合并：合并子问题的解成原问题的解。
分治算法很容易确定运行时间，关于分治法的更多内容将在第四章讲解。这里我们利用分治法，设计一个新的排序算法：归并排序。

五、归并排序

归并排序

归并排序遵循分治法，其工作原理如下：
分解：分解待排序的n个元素的序列成为各具n/2个元素的子序列；
解决：使用归并排序递归排序两个子序列
合并：将已排序的两个子序列合并产生总排序序列

上图是归并排序原理（非原创），图源：https://www.52pojie.cn/thread-804839-1-1.html（侵删）

归并排序的关键步骤是“合并”。我们通过调用一个过程merge(A,p,q,r)来完成，其中A是数组，p、q、r是数组下标，满足 p<=q<r。即 A[p…q] 和 A[q+1…r] 是两个排好序的相邻子数组，将两个子数组排序、合并，最终得到排好序的数组A[p…r]。

可以看出，图片右侧表示的高度是数列元素个数的对数。当待排序的元素个数为1时，开始合并。
排序的过程如下：首先将两个排好序的子数组分别装入两个空数组中，各自从头开始，选择较小的数放入待排序数组中，直到一个子数组全部选择完毕，将剩下的子数组全部按顺序装入，得到一个有序的大数组。当然，这里需要在每一步骤开始前判定是否有子数组全部选择完，这样做很麻烦。为了避免这种情况，我们在子数组后面加一张哨兵牌，这里我们使用∞作为哨兵。由于子数组中的任何一个数必定小于∞，所以我们不用担心子数组会空（至少剩下一个∞），当两个子数组都只剩下∞时，所有原子数组都已拍好序，则算法完毕。因为我们最多执行n=r-p+1个基本步骤（即待排序元素个数），所以合并需要θ(n)的时间。

下面给出merge的python3代码：

def merge(A,p,q,r):
    n1 = q-p+1                      #第一个子数组个数
    n2 = r-q                        #第二个子数组个数
    l = []                          #定义两个空数组
    m = []
    for i in range(0,n1):           #存放第一个子数组
        l.append(A[p+i])
    for i in range(0,n2):           #存放第二个子数组
        m.append(A[q+i+1])
    l.append(float('inf'))          #在最后存放一张哨兵牌,这里float('inf')表示∞
    m.append(float('inf'))
    i = 0                           #双指针
    j = 0
    for k in range(p,r+1):          #排序，小的放在前面
        if l[i]<=m[j]:
            arr[k] = l[i]
            i+=1
        else:
            arr[k] = m[j]
            j+=1

同样，我们来对循环不变式进行分析。在这里，循环不变式是指：子数组A[p…k-1]按照升序排列，包含两个数组L[1…n1+1]和R[1…n2+1]中的k-p个最小元素，进而L[i]和R[j]是各自数组中未被复制到A[p，k-1]中的最小元素。
初始化：在第一次迭代之前，子数组A为空，这里包含L和R的0个最小元素。此时 i = j = 1，L[ i ]和R[ i ]都是各自数组中排第一位的最小元素。
保持：在每次迭代时，将L[ i ]和R[ j ]比较，最小的元素复制到A中，原来A中有k-p个最小元素，复制之后，存在k-p+1个最小元素。通过for循环，增加k值之后，A仍然有k-p个最小元素。同时更新 i 或 j 的值，这时候就为下次迭代重新建立好了循环不变式。
终止：在终止时k=r+1。根据循环不变式，子数组A[p，k-1]就是A[p…r]且从小到大排列，包含L[1…n1+1]和R[1…n2+1]的r-p+1个最小元素。除了L和R之中人为添加的最大元素“哨兵”之外，所有元素均已复制到A中且排好序。

通过代码再次看运行时间。第一个for循环之前的代码需要常量时间。第一个和第二个for循环总共需要θ(n1+n2)=θ(n)的时间，第三个for循环需要迭代n次，每次需要常量时间，故总运行时间为θ(2n)。由于常数系数可以忽略，故为θ(n)。

merge已经分析完，下面是借助merge完成的归并排序的代码：

def merge_sort(A,p,r):
    if p < r:
        q=(p+q)//2
        merge_sort(A,p,q)
        merge_sort(A,q+1,r)
        merge(A,p,q,r)

在初次执行时，merge_sort中A为待排序数组、p为0、r为数组长度-1，排序过程见上图。

六、分析分治法

正如归并排序一样，当一个算法包含对自身的调用时（递归），我们用递归方程或递归式来描述运行时间。该方程根据在较小规模上的运行时间来描述规模为n时的总运行时间。我们可以根据数学工具求出算法性能的边界。
我们设T(n)为规模为n的问题运行所需要的时间。假设把问题分成a个子问题，，每个子问题的规模是原问题的1/b(在归并排序中，a=b，但是我们将看见在很多算法中，a不等于b)。求解规模n/b的子问题，需要T(n/b)的时间。所以a个子问题需要aT(n/b)的时间。如果分解问题需要时间D(n)，合并子问题的解为原问题的解需要时间C(n),可以得到求解时间的递归式：

下面我们分析归并排序n个数在最坏情况下运行时间T(n)的递归式。当n>1时，我们分解如下：
分解：分解仅需要计算中间位置，需要常量时间，因此D(n)=θ(1).
解决：递归求解两个规模均为n/2的子问题，故时间为2T(n/2)。
合并：在具有n个元素的子数组上调用merge需要θ(n)，所以C(n)=θ(n)。
D(n)+C(n)为线性函数，故取θ(n)。把他和2T(n/2)相加，得到：

进一步来研究这个式子。假设c为求解规模为1的问题所需要的时间以及在分解与合并处理每个数组元素所需时间，递归式又可以写为：

假设n刚好是2的幂，我们通过将递归式写成递归树的形式，扩展每个结点。从初始结点cn开始，两个子结点是两个较小的递归式T(n/2)，代价为cn/2。继续推，分成四个结点，代价为cn/4…直到最后，问题规模下降为1，每个结点代价为c。图如下：

可见，每一层所需要的时间都为cn，注意，完全扩展的递归树叶子结点共n个，层数为lgn+1层，而高度为lgn。我们把所有代价相加，总代价为cn(lgn+1)，即cnlgn+cn，忽略常数和低阶项，即为θ(nlgn)。

(本章结束)