分治算法

分治算法

1、数学归纳法
在学习分治算法之前，我们先来了解一下该技术的源头——数学归纳法。
数学归纳法（$Mathematical$ $Induction$，$MI$），是一种数学证明方法，通常被用于证明某个给定命题在整个（或者局部）自然数范围内成立。通常，数学归纳法的证明过程如下：

• 证明 $n=1$ 时命题成立；
• 假设 $n=m$ 时命题成立（归纳假设）；
• 根据归纳假设推导出 $n=m+1$ 时命题也成立（m代表任意自然数）

方法原理：
首先证明在某个起点值时命题成立，然后证明从一个值到下一个值的过程有效。当这两点都已经证明，那么任意值都可以通过反复使用这个方法推导出来。这种思想实际上几乎是所有递归算法的根据，假设现在有一个带有参数 $n$ 的问题，我们需要用归纳法设计出一个能够解决问题的有效算法。此时，如果我们知道如何求解带有参数小于 $n$ （如 $n-1,n/2$ 等）的相同问题（上述证明过程中的归纳假设），那么我们设计算法的主要思路就是如何将已知解法扩展到带有参数 $n$ 的情况。

2、分治算法原理
分治算法，顾名思义，就是“分而治之”，即将一个问题划分成若干子问题，并分别递归地解决每一个子问题，然后把这些子问题的解组合起来，构成原问题的最终解。因此，分治算法的核心操作概括为“分而治之”还有所不足，应当是：
分而治之，再作组合
现在，先根据一个简单的小例子来消化一下上述原理：
————————————$example\_0$——————————————
已知 $A[1\dots n]$ 是一整数数组，要求同时查找并返回数组元素的最大值和最小值（为了简化问题，这里假定 $n$ 是 $2$ 的整数幂）。我们先来看一个朴素算法：

• 输入：整数数组 $A[1\dots n]$，$n$ 为 $2$ 的整数幂
• 输出：一个数对 $(x,y)$，其中 $x$ 为数组元素的最小值，$y$ 为最大值
• $1.x\leftarrow A[1],y\leftarrow A[1]$
• $2.fori\leftarrow 2ton$
• $3.ifA[i]<xthenx\leftarrow A[i]$
• $4.ifA[i]>ytheny\leftarrow A[i]$
• $5.endfor$
• $6.return(x,y)$

上述算法的思路十分明显，将数组直接遍历一边，然后一边比较，一边更新最大值和最小值。显然，该算法执行的元素比较次数为 $2n-2$。现在再来看看利用分治策略设计的算法：
$min\_max(A[1\dots n],low,high)$

• 输入：整数数组 $A[1\dots n]$，$n$ 为 $2$ 的整数幂
• 输出：一个数对 $(x,y)$，其中 $x$ 为数组元素的最小值，$y$ 为最大值
• $1.min\_max(A,1,n)$
• 过程：$min\_max(A,low,high)$
• $1.ifhigh-low=1then$
• $2.ifA[low]<A[high]thenreturn(A[low],A[high])$
• KaTeX parse error: Expected 'EOF', got '}' at position 85: …,\space A[low])}̲
• $4.endif$
• $5.else$
• $6.mid\leftarrow \lfloor (low+high)/2\rfloor$
• $7.(x_1,y_1)\leftarrow min\_max(A,low,mid)$
• $8.(x_2,y_2)\leftarrow min\_max(A,mid+1,high)$
• 9.   x ← min ⁡ { x 1 ,   x 2 } \hspace{1cm}9.\space\hspace{1cm}x\leftarrow\min\{x_1,\space x_2\} 9. x←min{x1​, x2​}
• 10.   y ← max ⁡ { y 1 ,   y 2 } \hspace{0.85cm}10.\space\hspace{1cm}y\leftarrow\max\{y_1,\space y_2\} 10. y←max{y1​, y2​}
• $11.return(x,y)$
• $12.endif$

下面我们对应分治算法的原理来看一下 $min\_max(A[1\dots n],low,high)$：
“分而治之”：将数组分割成两半，$A[1\dots \frac{n}{2}]$ 和 $A[\frac{n}{2}+1\dots n]$，在每一半中找到最大值和最小值。该部分另一个重要之处在于什么时候停止“分”，当然是分到我们能够解决的子问题时就可以停止了，在上述例子中，就是当数组中仅有两个元素，我们能直接比较出最大值和最小值的时候。
“再作组合”：那么，我们怎么将两个子问题的解合并构成原问题的解呢？很简单，两个子问题各得到一对最大值和最小值，然后我们直接返回两个最小值中更小的那个和两个最大值中更大的那个即可。下面我们来看看该算法执行的元素比较次数，这里将其设为 $C(n)$，根据算法的思路，易得如下递推关系式：
$C(n)=\{\begin{array}{l}1ifn=2\\ \\ 2C(\frac{n}{2})+2ifn>2\end{array}$
直接展开得
$C(n)=2C(\frac{n}{2})+2$
$=2[2C(\frac{n}{4})+2]+2$
$=4C(\frac{n}{4})+4+2$
$=4[2C(\frac{n}{8})+2]+4+2$
$=8C(\frac{n}{8})+8+4+2$
$=\cdots =2^{k-1}C(\frac{n}{2^{k-1}})+2^{k-1}+2^{k-2}+\cdots +2^2+2,(k=\log n)$
$=2^{k-1}C(2)+{\sum }_{j=1}^{k-1}{2}^j$
$=\frac{3}{2}n-2$

显然快于之前的朴素算法。
————————————————————————————————
看到这里，相信大家对于分治策略设计的算法已经有了初步的了解。我们再来看一个例子：
————————————$example\_1$——————————————
之前我曾经写过一篇关于二分查找的博客，里面仅仅给出了二分查找最常见的算法思路——将给定元素 $x$ 与一个已排序数组 $A[low\dots high]$ 的中间元素进行比较，若 $x<A[mid],(mid=\lfloor (low+high)/2\rfloor )$，则不再考虑 $A[mid\dots high]$ 的部分，然后对 $A[low\dots mid-1]$ 部分重复执行上述操作，直到查找到目标元素为止 ，相应的，若有 $x>A[mid]$，则对 $A[mid+1\dots high]$ 部分重复执行上述操作。
那么，我们这里可以借助递归算法，设计出实现二分查找的另一种算法：

• 输入：按非降序排列的数组 $A[1\dots n]$ 和待查找元素 $x$
• 输出：若 $x=A[i]$，则返回 $i$，否则直接返回 $0$
• $1.binary\_search(A,1,n)$
• 过程：$binary\_search(A,low,high)$
• $1.iflow>highthenreturn0$
• $2.else$
• $3.mid\leftarrow \lfloor (low+high)/2\rfloor$
• $4.ifx=A[mid]thenreturnmid$
• $5.elseifx<A[mid]thenreturnbinary\_search(A,low,mid-1)$
• $6.elsereturnbinary\_search(A,mid+1,high)$
• $7.endif$

递归二分查找算法复杂度分析：
a. 若 $n=0$，此时数组为空，则不执行任何元素的比较操作；
b. 若 $n=1$，进入 $else$ 语句块，若数组内唯一的元素不等于指定元素，即 $x\ne A[mid]$，算法对空数组进行递归操作；
c. 若 $n>1$，运气好的话，有 $x=A[mid]$，算法仅仅执行一次元素比较，就直接返回正确结果，否则在执行一次元素比较后，还要继续递归调用数组的前/后一半。这里假设 $C(n)$ 为该算法面对最坏情况执行的元素比较次数，易得递推式：
$C(n)⩽\{\begin{array}{l}1ifn=1\\ \\ 1+C(\lfloor n/2\rfloor )ifn⩾2\end{array}$
已知 $\exists k\in Z,k⩾2,s.t.2^{k-1}⩽n<2^k$，下面直接将上述递推式展开，可知：
$C(n)⩽1+C(\lfloor n/2\rfloor )$
$⩽2+C(\lfloor n/4\rfloor )$
$⩽\cdots ⩽(k-1)+C(\lfloor n/x^{k-1}\rfloor )$
$=(k-1)+1=k$
将不等式 $2^{k-1}⩽n<2^k$ 同取对数并加上 $1$，可得 $k⩽\log n+1⩽k+1$，
$\Rightarrow k=\lfloor \log n\rfloor +1$
$\Rightarrow C(n)⩽\lfloor \log n\rfloor +1$
————————————————————————————————
根据上面的两个例子，相信大家对于分治算法的”分而治之“已经有了一定程度的了解，但是，并没有明确体会到“再作组合”对于分治算法的重要意义和具体操作，下面我们再结合一个简单的分治算法的例子来探究一下”分治“思想的本质。
————————————$example\_2$——————————————
合并排序：$merge\_sort$

• 输入：待排序数组 $A[1\dots n]$
• 输出：按非降序排列的数组 $A[1\dots n]$
• $1.merge\_sort(A,1,n)$
• 过程：$merge\_sort(A,low,high)$
• $1.iflow<highthen$
• $2.mid\leftarrow \lfloor (low+high)/2\rfloor$
• $3.merge\_sort(A,low,mid)$
• $4.merge\_sort(A,mid+1,high)$
• $5.merge(A,low,mid,high)$
• $6.endif$

这里我们就直接从明面上接触到了“再作组合”的概念——$merge$，这一算法主要用于合并两个已排序的表。现在假设有一个数组 $A[1\dots m],p,q,r$ 为其三个索引，并有 $1⩽p⩽q<r⩽m$，两个子数组 $A[p\dots q]$ 和 $A[q+1\dots r]$ 都按升序排列，合并这两个数组的过程，就是重新安排 $A$ 中元素的位置，使得子数组 $A[p\dots r]$ 也按升序排列。算法具体思路如下：
使用两个指针 $s,t$，在初始状态下，$s$ 指向 $A[p]$，$t$ 指向 $A[q+1]$，再利用一个空数组 $B[p\dots r]$ 作为暂存器。每一次比较元素 $A[s]$ 和 $A[t]$，将小的元素添加到暂存器中，若相同则添加 $A[s]$，然后再更新指针：若 $A[s]⩽A[t]$，则 $s$+=$1$，否则 $t$+=$1$。当条件 $s=q+1$ 或者 $t=r+1$ 满足时停止，若满足条件一，则把数组 $A[t\dots r]$ 中剩余的元素添加至 $B$ 中；若满足条件二，则把数组 $A[s\dots q]$ 中剩余的元素添加至 $B$ 中，最后再将暂存器数组 $B[p\dots r]$ 复制回 $A[p\dots r]$。实际上，该思路的核心就是同时遍历两个子数组，在比较之后将每个元素一一装到暂存器中，下面看伪代码：

• 输入：数组 $A[1\dots m]$ 和其三个索引 $p,q,r,1⩽p⩽q<r⩽m$，两个子数组 $A[p\dots q]$ 和 $A[q+1\dots r]$ 各自按升序排列。
• 输出：将子数组 $A[p\dots q]$ 和 $A[q+1\dots r]$ 合并为 $A[p\dots r]$
• $1.comment:B[p\dots r]$ 是一个辅助数组（暂存器）
• $2.s\leftarrow p;t\leftarrow q+1;k\leftarrow p$
• $3.whiles⩽qandt⩽r$
• $4.ifA[s]⩽A[t]then$
• $5.B[k]\leftarrow A[s]$
• $6.s\leftarrow s+1$
• $7.else$
• $8.B[k]\leftarrow A[t]$
• $9.t\leftarrow t+1$
• $10.endif$
• $11.k\leftarrow k+1$
• $12.endwhile$
• $13.ifs=q+1thenB[k\dots r]\leftarrow A[t\dots r]$
• $14.elseB[k\dots r]\leftarrow A[s\dots q]$
• $15.endif$
• $16.A[p\dots r]\leftarrow B[p\dots r]$

下面我们来看一下合并排序算法的操作过程：
假设有待排序数组 A [ 1 … 8 ] = { 9 , 4 , 5 , 2 , 1 , 7 , 4 , 6 } A[1\dots8]=\{9,4,5,2,1,7,4,6\} A[1…8]={9,4,5,2,1,7,4,6}，现在开始合并排序 $merge\_sort(A,1,8)$，调用该算法会引起一个隐含二叉树所表示的一系列递归调用，树的每个结点由上下两个数组组成，上面的数组是调用算法的输入，下面的数组则是调用算法的输出，换句话说，顶端数组是“分”后的待排序数组，底端数组是“治”后“再作组合”的数组。二叉树的每个边用表示控制流的两个相向的边取代，边上的标号指明这些递归调用发生的次序，显然，这个调用链顺序为：访问根、左子树和右子树，但是计算顺序略有不同：左子树、右子树、根。为了实现该算法，我们需要用一个栈来存储每次调用过程生成的局部数据。下面是图示：

算法分析：
显然，上述算法中的基本运算是元素比较，换句话说，我们可以认为运行时间与由算法执行的元素比较次数是成正比的。因此现在的主要工作，就是计算出合并排序算法对数组 $A[1\dots n]$ 排序时，总计执行的元素比较次数 $C(n)$。首先，为了简便计算，我们不失一般性地假设 $n=2^k,k\in N$。
再回到伪代码，
当 $n=1$ 时，算法不执行任何元素比较操作，即 $C(1)=0$；
当 $n⩾2$ 时，算法执行了步骤 $2\sim 5$，步骤 $3$ 和 $4$ 执行的元素比较操作都是 $C(\frac{n}{2})$ 次，根据合并操作算法的定义，易知合并两个子数组需要执行元素比较操作 $\frac{2}{n}\sim n-1$ 次。因此得到如下两个递推关系式：

• 最好情况：$C(n)=\{\begin{array}{l}0ifn=1\\ \\ 2C(\frac{n}{2})+\frac{n}{2}ifn⩾2\end{array}$，易得 $C(n)=\frac{n\log n}{2}$

• 最坏情况：$C(n)=\{\begin{array}{l}0ifn=1\\ \\ 2C(\frac{n}{2})+n-1ifn⩾2\end{array}$，展开得
  $C(n)=2C(\frac{n}{2})+n-1$
  $=2(2C(\frac{n}{2^2})+\frac{n}{2}-1)+n-1$
  $=2^{2}C(\frac{n}{2^2})+n-2+n-1$
  $=\cdots =2^{k}C(\frac{n}{2^k})+kn-2^{k-1}-2^{k-2}-\cdots -2-1$
  $=2^{k}C(1)+kn-{\sum }_{i=0}^{k-1}{2}^i$
  $=0+kn-(2^k-1)$
  $=n\log n-n+1$

综上，若 $n$ 是任意正整数，则有合并排序算法执行的元素比较次数为
$C(n)=\{\begin{array}{l}0ifn=1\\ \\ C(\lfloor n/2\rfloor )+C(\lceil n/2\rceil )+bnifn⩾2\end{array}$，其中 $b$ 为非负常数，易知解为 $C(n)=\Theta (n\log n)$，
进一步得到，算法的实际复杂度为 $T(n)=n\log n$。
————————————————————————————————

3、分治范式
一般来说，分治范式由以下步骤组成：

• $(1)$ 划分步骤
  在该步骤中，算法的输入被分为 $p⩾1$ 个部分，每个子实例的规模必须严格小于原始实例的规模 $n$。
  在绝大多数情况下，$p$ 都等于 $2$，例如归并排序算法 $merge\_sort$。有时候 $p$ 也会等于 $1$，此时，往往是将一部分输入直接丢弃，再对余下部分作递归，这种思路实际上等价于将算法输入划分为两个部分，但是其中一部分不考虑。
  注意：这里的 $p$ 也可以是与 $\log n,n^{\epsilon }(0<\epsilon <1)$ 一样的数量级，思维万万不可局限于部分整数。另外，划分步骤在几乎所有的分治算法中都是不变的——把输入数据分成 $p$ 部分，并且转到治理步骤。在许多分治算法中，它需要的时间为 $O(n)$，甚至仅仅是 $O(1)$。
• $(2)$ 治理步骤
  如果问题的规模大于某个预定的阈值 $n_0$，该步骤直接执行 $p$ 个递归调用即可。
  阈值是由算法的数学分析导出的，我们可以在不影响算法的时间复杂度的前提下，将任意常数量增加到阈值上。例如，在归并排序算法 $merge\_sort$ 中，我们有阈值 $n_0=1$，那么就算我们将其设置为任意正常数，都不会对其时间复杂度产生影响。这是因为根据定义，时间复杂度是用来衡量 $n\to \infty$ 时算法的有效性。
• $(3)$ 组合步骤
  该步骤主要解决组合 $p$ 个递归调用的解，进而得到期望的输出值的问题。在归并排序算法 $merge\_sort$ 中，这一步包含合并两个排序序列，这两个序列是借助合并算法 $merge$ 进行两次递归调用得到的。
  在分治算法中，组合步骤可以由合并、排序、搜索、找最值、矩阵运算等组成。
  注意：组合步骤对于执行一个实际的分治算法是非常关键的，因为算法的效率很大程度上就取决于我们如何设计这一步骤。

综上，我们可以得到分治算法的一般流程：

• $(1)$ 若实例 $I$ 的规模较小，则直接进行求解以获取答案，否则进入第 $2$ 步。这一点看起来是一句废话，但是在现实生活中，我们不会总是遇到大规模问题，若一味追求借助分治算法解决问题，有时候会弄巧成拙；
• $(2)$ 把实例 $I$ 划分为 $p$ 个大小几乎相同的子实例 $I_1,I_2,\dots ,I_p$；
• $(3)$ 对于每一个子实例 $I_j,1⩽j⩽p$，递归调用算法，并得到 $p$ 个部分解；
• $(4)$ 组合 $p$ 个部分解的结果，进而求出并返回原实例 $I$ 的解。

注意：子实例与原始实例性质完全一样，子实例之间可以彼此独立地求解，并且递归停止时子实例可以直接求解。我们将上面的一般流程概括为代码语言，即

• 分治算法：$Divide\_and\_Conquer(I)$
• $1.if|I|⩽cthenS(I)$
• $2.divideIinto{I}_1,I_2,\cdots ,I_p$
• $3.forj\leftarrow 1top$
• $4.y_j\leftarrow Divide\_and\_Conquer(I_j)$
• $5.returnmerge(y_1,y_2,\dots ,y_p)$

4、分治算法的典型算法例

$(1)$ 排序算法（归并排序和快速排序都运用了分治算法的思想）
上文中已经简单了解过了归并排序，这里我们再来看一下快速排序：
已知快速排序算法主要借助的就是“分治”的思想。那么，如何“分”，就是该算法的重要前提：
划分算法：设 $A[1\dots n]$ 是一个实数数组，要求将其整理为非降序排列。
我们先来设置分割点 $ref$，一般来说都会默认为数组的第一个元素，即 $ref=A[1]$。下面就需要调整数组顺序，使得小于或等于 $ref$ 的元素都排在它前面，所有大于 $ref$ 的元素都排在它的后面。
例如有 e x = { 5 , 3 , 9 , 2 , 7 , 1 , 8 } ex=\{5,3,9,2,7,1,8\} ex={5,3,9,2,7,1,8}，再执行完划分算法后就要得到 e x = { 1 , 3 , 2 , 5 , 7 , 9 , 8 } ex=\{1,3,2,5,7,9,8\} ex={1,3,2,5,7,9,8}。但是，这又是如何得到的呢？实际上有很多策略都可以实现划分，但是上述的例子中，采取的是如下算法：

• 输入：数组 $A[low,high]$
• 输出：新数组 $A$ 和 $ref=A[low]$ 的在新数组中的位置
• $1.i\leftarrow low$
• $2.ref\leftarrow A[low]$
• $3.forj\leftarrow low+1tohigh$
• $4.ifA[j]⩽refthen$
• $5.i\leftarrow i+1$
• $6.ifi\ne jthenswap(A[i],A[j])$
• $7.endif$
• $8.endfor$
• $9.swap(A[low],A[i])$
• $10.w\leftarrow i$
• $11.returnAandw$

上述算法在执行过程中主要利用 $i,j$ 指针，先将其设置为 $i=low,j=low+1$，然后借助 $for$ 循环遍历数组，$for$ 循环执行结束后得到：

1. $A[low]=ref$
2. $A[k]⩽ref,low⩽k⩽i$
3. $A[k]>ref,i<k⩽j$

最后再将 $A[i]$ 与 $ref$ 交换，这样就得到了我们期待的新数组。下面我们根据一个例子来具体看一下划分算法的执行步骤：

初始值情况	{ 5 , 7 , 1 , 6 , 4 , 8 , 3 , 2 } \{5,7,1,6,4,8,3,2\} {5,7,1,6,4,8,3,2} 此时有 $low=1,high=8,ref=5$
$(1)$	$i=low,A[i]=5;j=low+1,A[j]=7$
$(2)$	$j=3$ 时 A [ 3 ] = 1 ⩽ r e f = 5 ⇒ i = 2 ≠ j ⇒ { 5 , 1 , 7 , 6 , 4 , 8 , 3 , 2 } A[3]=1\leqslant ref=5\Rightarrow i=2\neq j\Rightarrow\{5,1,7,6,4,8,3,2\} A[3]=1⩽ref=5⇒i=2​=j⇒{5,1,7,6,4,8,3,2}
$(3)$	$j=5$ 时 A [ 5 ] = 4 ⩽ r e f = 5 ⇒ i = 3 ≠ j ⇒ { 5 , 1 , 4 , 6 , 7 , 8 , 3 , 2 } A[5]=4\leqslant ref=5\Rightarrow i=3\neq j\Rightarrow\{5,1,4,6,7,8,3,2\} A[5]=4⩽ref=5⇒i=3​=j⇒{5,1,4,6,7,8,3,2}
$(4)$	$j=7$ 时 A [ 7 ] = 3 ⩽ r e f = 5 ⇒ i = 4 ≠ j ⇒ { 5 , 1 , 4 , 3 , 7 , 8 , 6 , 2 } A[7]=3\leqslant ref=5\Rightarrow i=4\neq j\Rightarrow\{5,1,4,3,7,8,6,2\} A[7]=3⩽ref=5⇒i=4​=j⇒{5,1,4,3,7,8,6,2}
$(5)$	$j=8$ 时 A [ 8 ] = 2 ⩽ r e f = 5 ⇒ i = 5 ≠ j ⇒ { 5 , 1 , 4 , 3 , 2 , 8 , 6 , 7 } A[8]=2\leqslant ref=5\Rightarrow i=5\neq j\Rightarrow\{5,1,4,3,2,8,6,7\} A[8]=2⩽ref=5⇒i=5​=j⇒{5,1,4,3,2,8,6,7}
$(6)$	$j=8=high\Rightarrow$ $for$ 循环停止
$(7)$	s w a p ( A [ l o w ] , A [ i ] ) ⇒ { 2 , 1 , 4 , 3 , 5 , 8 , 6 , 7 } swap(A[low],A[i])\Rightarrow\{2,1,4,3,5,8,6,7\} swap(A[low],A[i])⇒{2,1,4,3,5,8,6,7}
$(8)$	算法执行完毕

最后注意到上述算法仅仅用到一个额外变量来存储它的局部变量，因此该划分算法的空间复杂度为 $\Theta (1)$。下面，我们就可以结合划分算法，借助递归调用完成快速排序的算法设计：

—————————-——$quick\_sort$——————————————

• 输入：待排序数组 $A[1\dots n]$ 和数组起始下标索引
• 输出：非降序排列数组 $A[1\dots n]$
• $quick\_sort(A[1\dots n],1,n)$
• 过程：$quick\_sort(A,low,high)$
• $1.iflow<highthen$
• $2.i\leftarrow low$
• $3.ref\leftarrow A[low]$
• $4.forj\leftarrow low+1tohigh$
• $5.ifA[j]⩽refthen$
• $6.i\leftarrow i+1$
• $7.ifi\ne jthenswap(A[i],A[j])$
• $8.endif$
• $9.endfor$
• $10.swap(A[low],A[i])$
• $11.w\leftarrow i$
• $12.quick\_sort(A,low,w-1)$
• $13.quick\_sort(A,w+1,high)$
• $14.endif$

————————————————————————————————

下面再来看一下快速排序算法时间复杂度的计算。

• a. 最坏情况
  对于算法 $quick\_sort(A,low,high)$ 的每次调用，$ref=A[low]$ 都是数组中的最小值元素，那么仅仅存在一个有效的递归调用，而另一个调用就将作用在空数组上，即算法是由调用 $quick\_sort(A,1,n)$ 开始，下一步的两个递归调用分别是 $quick\_sort(A,1,0)$ 和 $quick\_sort(A,2,n)$，其中，第一个就是无效调用。
  因此，若输入的待排序数组已经是非降序排列的，最坏情况就出现了。简单来说，下面对于 $quick\_sort(A,low,high)$ 过程的 $n$ 次调用将发生$quick\_sort(A,1,n),quick\_sort(A,2,n),\dots ,quick\_sort(A,n,n)$。
  由于对于输入大小为 $j$ 的元素，划分算法执行的元素比较次数为 $j-1$，因此在最坏情况下，算法 $quick\_sort(A,low,high)$ 执行的元素总比较次数是
  $(n-1)+(n-2)+\cdots +1+0=\frac{n(n-1)}{2}=\Theta (n^2)$
  但是我们要注意一点，如果我们总是在线性时间内选择中项作为分割点 $ref$，最坏情况下的运行时间可以被改进为 $\Theta (n\log n)$，主要是因为这么划分元素是高度平衡的，而在这种情况下，两个递归调用具有几乎相同数目的元素，进而得到计算比较次数的递推式：
  $C(n)=\{\begin{array}{l}0ifn=1\\ \\ 2C(\frac{n}{2})+\Theta (n)ifn>1\end{array}$
  最终求得 $C(n)=\Theta (n\log n)$，但是找出中项的算法对时间复杂度的影响不可控，因而不值得与 $quick\_sort(A,low,high)$ 算法配合使用。

• b. 平均情况
  我们必须承认最坏情况会在算法执行时发生，但是它同时也属于极端情况，即在实际情况下是很少发生的，因此用最坏情况下的算法运行时间来界定时间复杂度很不合理。下面来看看平均情况：
  为了便于理解，我们假定输入数据是互不相同的（这是不失一般性的，因为算法的性能与输入数据值是无关的，有关系的是它们的相对次序），不如更进一步，我们直接假设进行排序的元素是前 $n$ 个正整数 $1,2,\dots ,n$。
  在分析算法的平均性能的过程中，我们必须高度关注输入数据的概率分布，这里采用简化分析的方法，就假定元素的每个排列的出现是等可能的，即对于 $1,2,\dots ,n$ 的 $n!$ 种排列情况来说，每一个排列的出现是等可能的，这一点主要是为了确保数组中的每个数被选作 $ref$ 的可能性是一样的，即数组 $A$ 中任意元素被选为分割点的概率都是 $\frac{1}{n}$。设 $C(n)$ 为对于大小为 $n$ 的输入数据，$quick\_sort(A,low,high)$ 算法所执行的平均比较次数，结合上述假设和算法的具体设计，得到
  $C(n)=(n-1)+\frac{1}{n}{\sum }_{w=1}^n(C(w-1)+C(n-w))$
  $\because {\sum }_{w=1}^{n}C(n-w)=C(n-1)+C(n-2)+\cdots +C(0)={\sum }_{w=1}^{n}C(w-1)$
  $\therefore C(n)=(n-1)+\frac{2}{n}{\sum }_{w=1}^{n}C(w-1)$
  $\Rightarrow nC(n)=n(n-1)+2{\sum }_{w=1}^{n}C(w-1)$
  $\Rightarrow (n-1)C(n-1)=(n-1)(n-2)+2{\sum }_{w=1}^{n-1}C(w-1)$
  $\Rightarrow \frac{C(n)}{n+1}=\frac{C(n-1)}{n}+\frac{2(n-1)}{n(n+1)}=D(n)$
  $\Rightarrow D(n)=D(n-1)+\frac{2(n-1)}{n(n+1)}andD(1)=0$
  $\Rightarrow D(n)=2{\sum }_{j=1}^n\frac{j-1}{j(j+1)}$
  $=2{\sum }_{j=1}^n\frac{2}{j+1}-2{\sum }_{j=1}^n\frac{1}{j}$
  $=4{\sum }_{j=2}^{n+1}\frac{1}{j}-2{\sum }_{j=1}^n\frac{1}{j}$
  $=2{\sum }_{j=1}^n\frac{1}{j}-\frac{4n}{n+1}$
  $=2\ln n-\Theta (1)$
  $=\frac{2}{\log e}\log n-\Theta (1)$
  $\approx 1.44\log n$
  $\Rightarrow C(n)=(n+1)D(n)\approx 1.44n\log n$

综上，我们可以得到 $quick\_sort$ 算法的时间复杂度为 $\Theta (n\log n)$。

$(2)$ 矩阵乘法问题，即设 $A,B$ 是两个 $n\times n$ 的矩阵，求 $C=A\times B$

• 我们先来看一下最传统的直接相乘法：
  矩阵 $C$ 可以简单表示为 $C=[c_{ij}{]}_{i=1,2,\dots ,n;j=1,2,\dots ,n}$，根据矩阵乘法的定义，易知 $c_{ij}={\sum }_{k=1}^n{a}_{ik}{b}_{kj}$，这样我们就能直接求出矩阵 $C$，但是，直接的想法是以复杂的运算为代价的。我们假设每做一次标量乘法耗时 $m$，每做一次标量加法耗时 $a$，那么，直接相乘算法的时间复杂度就是
  $T(n)=n^2\ast n\ast m+n^2\ast (n-1)\ast a=\Theta (n^3)$
• 显然，当数据规模达到一定的规模，这是难以接受的。因此，我们希望利用分治策略设计出一个效率更高的算法——分块矩阵法。顾名思义，这种方法是将大矩阵进行分块处理，分割成一个一个小矩阵，再按照矩阵乘法法则展开计算，即有 $A=\left(\begin{array}{cc}{A}_{11}& A_{12}\\ & \\ A_{21}& A_{22}\end{array}\right),B=\left(\begin{array}{cc}{B}_{11}& B_{12}\\ & \\ B_{21}& B_{22}\end{array}\right),C=\left(\begin{array}{cc}{C}_{11}& C_{12}\\ & \\ C_{21}& C_{22}\end{array}\right)$
  $\therefore C_{11}=A_{11}{B}_{11}+A_{12}{B}_{21}$
  $C_{12}=A_{11}{B}_{12}+A_{12}{B}_{22}$
  $C_{21}=A_{21}{B}_{11}+A_{22}{B}_{21}$
  $C_{22}=A_{21}{B}_{12}+A_{22}{B}_{22}$
  $\Rightarrow C=\left(\begin{array}{cc}{A}_{11}{B}_{11}+A_{12}{B}_{21}& A_{11}{B}_{12}+A_{12}{B}_{22}\\ & \\ A_{21}{B}_{11}+A_{22}{B}_{21}& A_{21}{B}_{12}+A_{22}{B}_{22}\end{array}\right)$
  根据上式，我们可以看出需要 $8$ 次 $\frac{n}{2}\times \frac{n}{2}$ 矩阵乘法和 $4$ 次 $\frac{n}{2}\times \frac{n}{2}$ 矩阵加法，这里设 $a,m$ 分别表示数量加法和乘法的耗时，因此易知：
  $T(n)=\{\begin{array}{l}mifn=1\\ \\ 8T(\frac{n}{2})+4(\frac{n}{2}{)}^{2}aifn⩾2\end{array}$
  $\Rightarrow T(n)=(m+\frac{a{2}^2}{8-2^2})n^3-(\frac{a{2}^2}{8-2^2})n^2=m{n}^3+a{n}^3-a{n}^2=\Theta (n^3)$
  算法的耗时并没有改进，相反，耗费的时间甚至比传统的计算算法还要多（主要是耗在递归上了）。但这并不意味着分治策略是无效的，不过我们需要扭转一下思维定式。
• $Strassen$ 算法，它的核心思路就是先利用分治策略分割矩阵，然后再通过增加加减法的次数来减少乘法次数。
  算法引入 $M_1=(A_{11}+A_{22})(B_{21}+B_{22})$
  $M_2=(A_{21}+A_{22})B_{11}$
  $M_3=A_{11}(B_{12}-B_{22})$
  $M_4=A_{22}(B_{21}-B_{11})$
  $M_5=(A_{11}+A_{12})B_{22}$
  $M_6=(A_{21}-A_{11})(B_{11}+B_{12})$
  $M_7=(A_{12}-A_{22})(B_{21}+B_{22})$
  则有 $C_{11}=M_1+M_4-M_5+M_7$
  $C_{12}=M_3+M_5$
  $C_{21}=M_2+M_4$
  $C_{22}=M_1+M_3-M_2+M_6$，这么做并没有改变结果
  $\Rightarrow C=\left(\begin{array}{cc}{M}_1+M_4-M_5+M_7& M_3+M_5\\ & \\ M_2+M_4& M_1+M_3-M_2+M_6\end{array}\right)$
  进而得到 $T(n)=\{\begin{array}{l}mifn=1\\ \\ 7T(\frac{n}{2})+18(\frac{n}{2}{)}^{2}aifn⩾2\end{array}$
  $\Rightarrow T(n)=(m+\frac{\frac{9a}{2}{2}^2}{7-2^2})n^{\log 7}-(\frac{\frac{9a}{2}{2}^2}{7-2^2})n^2$
  $=m{n}^{\log 7}+6a{n}^{\log 7}-6a{n}^2$
  $=\Theta (n^{\log 7})=\Theta (n^{2.81})$
  我们也可以根据 $MasterTheorem$ 的结论进行估算：
  $T(n)=\Theta (n^{{\log }_b^a})=\Theta (n^{{\log }_2^7})=\Theta (n^{2.81})$
  耗时缩短，传统算法的效率得到了改进。

$(3)$ 大整数相乘
通常，我们在分析算法的计算复杂度时，都会将加法和乘法运算当作基本运算来处理，即将执行一次加法或乘法运算耗费的计算时间默认为一个常数，常数值的大小主要取决于计算机硬件的处理速度。而我们也知道，常数时间对于算法时间复杂度的影响是很有限的，往往会忽略不计。
但是，这一默认行为仅仅在参加运算的整数处于一定范围内是才是合理的（这个整数范围主要取决于计算机硬件对整数的表示），换句话说，在某些情况下我们需要处理很大的整数，它无法在计算机硬件能够直接表示的整数范围内进行处理。此时，我们就必须使用软件的方法来实现大整数的算术运算，而该操作的耗费时间，就不是一个常数了。我们都知道计算机处理数字是一般都会使用二进制，这里就举一个二进制整数相乘的例子：
假设有两个 $nbit$ 的二进制整数 $x,y$，需要计算 $xy$。

• 传统乘法运算：相信大家在小学的时候都学习过十进制乘法的计算法则（逐位相乘），二进制也是一样的，这里我们可以将位（$bit$）的乘法或加法运算视作基本运算，那么逐位相乘算法的时间复杂度为 $T(n)=\Theta (n^2)$。
• 分治策略改写：将二进制整数分为两部分，即有 $x=a\cdot 2^{\frac{n}{2}}+b,y=c\cdot 2^{\frac{n}{2}}+d$，这一操作一开始可能不易理解，我们举个例子，现在有 $x=(1101{)}_2=13$，那么可以得到 $a=(11{)}_2=3,b=(01{)}_2=1,x=a\cdot 2^{\frac{n}{2}}+b=3\cdot 2^2+1=13$。
  因此，$xy=(a\cdot 2^{\frac{n}{2}}+b)(c\cdot 2^{\frac{n}{2}}+d)=ac\cdot 2^n+(ad+cb)\cdot 2^{\frac{n}{2}}+bd$，下面我们来看一下该算法的时间复杂度：
  $(1)$ $4$ 次 $\frac{n}{2}bit$ 位数的乘法（$ac,ad,cb,bd$）$\Rightarrow 4T(\frac{n}{2})$
  $(2)$ $ac$ 左移 $n$ 位（$ac\cdot 2^n$，这里涉及到二进制移位操作实现乘法）$\Rightarrow \Theta (n)$
  $(3)$ 求解 $ad+cb$ 时执行了 $nbit$ 加法 $\Rightarrow \Theta (n)$
  $(4)$ $ad+cb$ 左移 $\frac{n}{2}$ 位（$(ad+cb)\cdot 2^{\frac{n}{2}}$）$\Rightarrow \Theta (n)$
  $(5)$ 两个加法操作（$ac\cdot 2^n+(ad+cb)\cdot 2^{\frac{n}{2}}+bd$）$\Rightarrow \Theta (n)$
  $\Rightarrow T(n)=\{\begin{array}{l}aifn=1\\ \\ 4T(\frac{n}{2})+\Theta (n)ifn>1\end{array}\Rightarrow T(n)=\Theta (n^2)$
  没有显著提高效率，那么我们来看一下如何在分治策略的基础上降低时间复杂度
• $\because ad+cb=(a+b)(c+d)-ac-bd$
  $\therefore xy=(a\cdot 2^{\frac{n}{2}}+b)(c\cdot 2^{\frac{n}{2}}+d)$
  $=ac\cdot 2^n+(ad+cb)\cdot 2^{\frac{n}{2}}+bd$
  $=ac\cdot 2^n+((a+b)(c+d)-ac-bd)\cdot 2^{\frac{n}{2}}+bd$
  $\therefore T(n)=\{\begin{array}{l}aifn=1\\ \\ 3T(\frac{n}{2})+\Theta (n)ifn>1\end{array}\Rightarrow T(n)=\Theta (n^{\log 3})=\Theta (n^{1.59})$
  算法效率有了显著的提高。

$(4)$ $Hanoi$ 塔问题
设 $a,b,c$ 是 $3$ 个塔座。开始时，在塔座 $a$ 上有一叠圆盘（总计 $n$ 个），这些圆盘自下而上、由大到小地叠在一起，各圆盘从小到大编号为 $1,2,3,\dots ,n$。
现在要求将塔座 $a$ 上的这一叠圆盘移到塔座 $c$ 上，并且按照原顺序堆叠。同时，在移动圆盘时必须遵循以下规则：

• $(1)$ 每次只能移动一个圆盘
• $(2)$ 无论何时都不允许将较大的圆盘压在较小的圆盘上
• $(3)$ 在满足上述规则的前提下，可以将圆盘移至 $a,b,c$ 中任意一个塔座上

分析该问题，我们得到以下基本思路：

• $(1)$ 以 $c$ 为中介，从 $a$ 将 $1$ 至 $n-1$ 号圆盘移至 $b$
• $(2)$ 将 $a$ 中剩下的第 $n$ 号圆盘移至 $c$
• $(3)$ 以 $a$ 为中介，从 $b$ 将 $1$ 至 $n-1$ 号圆盘移至 $c$

最终得到算法思路：

• 输入：圆盘个数 $n$，$3$ 个塔座 $a,b,c$
• 输出：将塔座 $a$ 中的所有圆盘遵循移动规则移至塔座 $c$
• $1.hanoi(n,a,b,c)$
• 过程：$voidhanoi(intn,inta,intb,intc)$
• $1.ifn>0$
• 2.   h a n o i ( n − 1 , a , b , c )   { a → b , c \hspace{1cm}2.\space\hspace{1cm}hanoi(n-1,a,b,c)\space\{a\rightarrow b,c 2. hanoi(n−1,a,b,c) {a→b,c 做辅助 $\}$
• 3.   m o v e ( a , c )   { a → c } \hspace{1cm}3.\space\hspace{1cm}move(a,c)\space\{a\rightarrow c\} 3. move(a,c) {a→c}
• 4.   h a n o i ( n − 1 , b , c , a )   { b → c , a \hspace{1cm}4.\space\hspace{1cm}hanoi(n-1,b,c,a)\space\{b\rightarrow c,a 4. hanoi(n−1,b,c,a) {b→c,a 做辅助 $\}$
• $5.endif$

$(5)$ 寻找中项和第 $k$ 小元素
给定一排序完毕的数组 $A[1\cdots n]$，我们按照字面义将“中项”定义为数组中间的元素：若 $n$ 为奇数，则中项就是数组中的第 $\frac{n+1}{2}$ 个元素；若 $n$ 为偶数，则存在两个中间元素，即第 $\frac{n}{2}$ 个元素和第 $\frac{n}{2}+1$ 个元素，此时，我们人为地选取第 $\frac{n}{2}$ 个元素作为中项。
综上，我们得到中项的基本数学定义——第 $\lceil n/2\rceil$ 个元素。
因此，我们可以根据中项的定义得到查找中项的直接方法：先排序，再返回第 $\lceil n/2\rceil$ 个元素值。然而根据这一方法，实际上我们可以查找任意数组中的第 $k$ 小元素，寻找中项仅仅只是其中的一个特例而已（$k=\lceil n/2\rceil$）。显然，上面提到的直接查找算法的时间复杂度为 $\Omega (n\log n)$，我们希望通过分治策略改进算法效率，那么可以先参考二分查找——以中间元素为基准分割数组，然后通过判断抛弃部分元素，不断减小问题规模。据此，我们可以初步给出以下思路：

• 若数组 $A[1\dots n]$ 中的元素个数小于一个阈值，那么我们可以采用直接查找的方式找到第 $k$ 小元素。这一阈值的含义就是说，当数组规模小于阈值时，直接查找的时间复杂度是完全可以接受的，甚至比优化之后效率更高。
• 若数组 $A[1\dots n]$ 中的元素个数大于该阈值，就将 $n$ 个元素分成 $\lfloor n/5\rfloor$ 组。每组 $5$ 个元素，注意，如果 $n$ 不是 $5$ 的倍数，则暂时排除剩余的元素，但这并不意味着排除第 $k$ 小元素在这些丢弃元素中的可能性。
  对每组元素依次排序，并取出他们的中项（即第 $3$ 个元素），因此，我们可以得到 $\lfloor n/5\rfloor$ 个中项组成的新数组，我们将新数组的中项记作 $mm$。然后我们可以根据 $mm$ 将数组 $A[1\dots n]$ 分为三个子数组： A 1 = { a ∣ a < m m } ,   A 2 = { a ∣ a = m m } ,   A 3 = { a ∣ a > m m } A_1=\{a|a<mm\},\space A_2=\{a|a=mm\},\space A_3=\{a|a>mm\} A1​={a∣a<mm}, A2​={a∣a=mm}, A3​={a∣a>mm}。然后再判断第 $k$ 小元素可能在哪个子数组中出现：若在 $A_2$ 中出现，则已经找到；否则，对 $A_1/A_3$ 进行递归。

根据上述思路，得到算法 $select(A[1\dots n],low,high,k)$

• 输入：数组 $A[1\dots n]$ 和整数 $k$
• 输出：数组 $A$ 中的第 $k$ 小元素
• $1.select(A,1,n,k)$
• 过程：$select(A,low,high,k)$
• $1.p\leftarrow high-low+1$
• $2.ifp<$ 阈值 $then$ 对 $A$ 进行排序，并 $returnA[k]$
• $3.q\leftarrow \lfloor p/5\rfloor$，将数组 $A$ 分成 $q$ 组，每组 $5$ 个元素。若 $5$ 不整除 $p$，则排除剩余的元素
• $4.$对 $q$ 组数组进行分别排序，将各自中项 合并为新数组 $M$
• $5.mm\leftarrow select(M,1,q,\lceil q/2\rceil )$
• $6.$将 $A[low\dots high]$ 分为 $3$ 组：
• A 1 = { a ∣ a < m m } \hspace{2cm}A_1=\{a|a<mm\} A1​={a∣a<mm}
• A 2 = { a ∣ a = m m } \hspace{2cm}A_2=\{a|a=mm\} A2​={a∣a=mm}
• A 3 = { a ∣ a > m m } \hspace{2cm}A_3=\{a|a>mm\} A3​={a∣a>mm}
• $7.case$
• $|A_1|⩾k:returnselect(A_1,1,|A_1|,k)$
• $|A_1|+|A_2|⩾k:returnmm$
• $|A_1|+|A_2|<k:returnselect(A_3,1,|A_3|,k-|A_1|-|A_2|)$
• $8.endcase$

时间复杂度分析：
已知 $select$ 算法先将数组中的元素划分为各组，每组含 $5$ 个元素，现在将每组从低到顶按升序排列，绘制算法示意图。

由图可知，$W$ 区域中的所有元素都不大于 $mm$，$X$ 区域中的所有元素都不小于 $mm$。现在设 A 1 ′ = { x ∣ x ⩽ m m } ,   A 3 ′ = { x ∣ x ⩾ m m } A_1'=\{x|x\leqslant mm\},\space A_3'=\{x|x\geqslant mm\} A1′​={x∣x⩽mm}, A3′​={x∣x⩾mm}，此外，根据算法定义易知 A 1 = { x ∣ x < m m } ,   A 3 = { x ∣ x > m m } A_1=\{x|x<mm\},\space A_3=\{x|x>mm\} A1​={x∣x<mm}, A3​={x∣x>mm}。因此，结合算法示意图可以得到
$|A_1^{\prime }|⩾3\lceil \frac{\lfloor n/5\rfloor }{2}\rceil ⩾\frac{3}{2}\lfloor n/5\rfloor$
$\Rightarrow |A_3|⩽n-\frac{3}{2}\lfloor n/5\rfloor ⩽n-\frac{3}{2}(\frac{n-4}{5})=n-0.3n+1.2=0.7n+1.2$
$\Rightarrow |A_3^{\prime }|⩾\frac{3}{2}\lfloor n/5\rfloor ,|A_1|⩽0.7n+1.2$
根据上式，我们可以得到集合 $A_1,A_3$ 中元素数量的上界值，即小于 $mm$ 的元素的数量和大于 $mm$ 的元素的数量大致上都不能多于 $0.7n$。估算 $select$ 算法时间复杂度需要依次观察每一步的耗费：
$step1$：$\Theta (1)$
$step2$：$\Theta (1)$
$step3$：$\Theta (n)$
$step4$：$\Theta (n)$
$step5$：$\Theta (\lfloor n/5\rfloor )$
$step6$：$\Theta (n)$
$step7$：$\Theta (0.7n+1.2)$，现在希望进一步规整化这一表示，为此假设 $0.7n+1.2⩽\lfloor 0.75n\rfloor$。因此，若 $0.7n+1.2⩽0.75n-1$，即当 $n⩾44$ 时上述不等式将会成立，因此在 $select$ 算法中我们一般将阈值设置为 $44$。根据上面的分析，我们可以得到关于时间复杂度的递推关系式：
$T(n)=\{\begin{array}{l}cifn<44\\ \\ T(\lfloor n/5\rfloor )+T(\lfloor 3n/4\rfloor )+cnifn⩾44\end{array}$，$c$ 是一个足够大的常数。

$(6)$ 最接近点对问题
设 $S$ 是平面上 $n$ 个点的集合，而最接近点对问题就是在 $S$ 中找到一个点对 $p$ 和 $q$ 的问题，使其相互距离最短。即考虑在 $S$ 中找到 $p_1=(x_1,y_1),p_2=(x_2,y_2)$，使两点之间的距离 $d(p_1,p_2)=\sqrt{(x_1-x_2{)}^2+(y_1-y_2{)}^2}$ 在所有 $S$ 中点对间最小。
最直接的传统算法就是简单检验所有可能的 $\frac{n(n-1)}{2}$ 个距离并返回最短间距的点对。但是在这里我们将利用分治策略，设计一个时间复杂度为 $\Theta (n\log n)$ 的算法来解决最接近点对问题（注意是返回点对之间的距离，而不是找到具有最短距离的点对，这两者的难度是截然不同的）。下面我们来简单看一下算法思路：

• 以 $x$ 坐标升序的标准对点集 $S$ 中所有的点进行排序
• 用垂直线 $L$ 将点集 $S$ 大致划分为两个子集 $S_l,S_r$，使 $|S_l|=\lfloor |S|/2\rfloor ,|S_r|=\lceil |S|/2\rceil$。设垂直线 $L$ 是经过 $x$ 坐标为 $S[\lfloor n/2\rfloor ]$ 的垂直线，那么，$S_l$ 中所有的点都分布在 $L$ 的左侧，$S_r$ 中所有的点都分布在 $L$ 的右侧
• 对上述操作进行递归，求出两个子集 $S_l,S_r$ 的最小间距 ${\delta }_l$ 和 ${\delta }_r$
• 求出 $S_l$ 中的点与 $S_r$ 中的点之间的最小间距 ${\delta }^{\prime }$
• 返回 $\min ({\delta }_l,{\delta }_r,{\delta }^{\prime })$

我们知道绝大多数分治算法的组合步骤耗费最多，上述算法也是如此，核心工作就在于如何优化 ${\delta }^{\prime }$ 的求解操作，已知利用朴素算法计算 $S_l$ 中每个点和 $S_r$ 中每个点之间的距离需要 $\Omega (n^2)$。
设 δ = min ⁡ { δ l , δ r } \delta=\min\{\delta_l,\delta_r\} δ=min{δl​,δr​}，若最接近点对由 $S_l$ 中的点 $p_l$ 和 $S_r$ 中的点 $p_r$ 组成，则 $p_l,p_r$ 一定在划分线 $L$ 的距离 $\delta$ 内，换句话说，如果令 $S_l^{\prime }$ 和 $S_r^{\prime }$ 分别表示 $S_l$ 和 $S_r$ 中距离 $L$ 小于 $\delta$ 的点的集合，则 $p_l$ 一定在 $S_l^{\prime }$ 中，$p_r$ 一定在 $S_r^{\prime }$ 中。尽管在最坏情况下，比较 $S_l^{\prime }$ 中的每一个点和 $S_r^{\prime }$ 中的每一个点的距离需要耗时 $\Omega (n^2)$，此时 $S_l^{\prime }=S_l,S_r^{\prime }=S_r$。但是，这些比较操作并非都需要真正执行，实际上我们只需要比较 $S_l$ 中每个点 $p$ 和距离 $p$ 在 $\delta$ 内的那些点。假设 ${\delta }^{\prime }⩽\delta$，则存在 $p_l\in S_l^{\prime },p_r\in S_r^{\prime }$，有 $d(p_l,p_r)={\delta }^{\prime }$，进而知道 $p_l,p_r$ 之间的垂直距离不超过 $\delta$。此外，由于 $p_l\in S_l^{\prime },p_r\in S_r^{\prime }$，易知这两点都在以 $L$ 为中心的 $\delta \times 2\delta$ 矩形区内或者边界上。设 $T$ 是两个垂直带（距离 $L$ $\delta$ 的两条直线）内点的集合，若在 $\delta \times 2\delta$ 矩形区内，任意两点间的距离一定不超过 $\delta$，则这个矩形最多可以容纳 $8$ 个点（可以结合鸽巢原理证明）：其中最多 $4$ 个点属于点集 $S_l$，$4$ 个点属于点集 $S_r$。当 $S_l$ 中的一个点与 $S_r$ 中的一个点在矩形的顶与 $L$ 的交点处重合，并且 $S_l$ 中的一个点与 $S_r$ 中的一个点在矩形的底与 $L$ 的交点处重合，则得到最大数。因此，$T$ 中的每个点最多需要和 $T$ 中的 $7$ 个点进行比较。
综上，我们可以得到如下算法：

• 输入：平面上 $n$ 个点的集合 $S$
• 输出：$S$ 中两点的最小距离
• $1.$以 $x$ 坐标升序的准则对 $S$ 中的点进行排序
• $2.Y\leftarrow$以 $y$ 坐标升序的准则对 $S$ 中的点进行排序
• $3.\delta \leftarrow cp(1,n)$
• 过程：$cp(low,high)$
• $1.ifhigh-low+1⩽3then$直接计算 $\delta$
• $2.else$
• $3.mid\leftarrow \lfloor (low+high)/2\rfloor$
• $4.x_0\leftarrow x(S[mid])$
• $5.{\delta }_l\leftarrow cp(low,mid)$
• $6.{\delta }_r\leftarrow cp(mid+1,high)$
• 7.   δ ← min ⁡ { δ l , δ r } \hspace{1cm}7.\space\hspace{1cm}\delta\leftarrow \min\{\delta_l,\delta_r\} 7. δ←min{δl​,δr​}
• $8.k\leftarrow 0$
• 9.   f o r    i ← 1    t o    n    { \hspace{1cm}9.\space\hspace{1cm}for\space\space i\leftarrow1\space\space to\space\space n\space\space\{ 9. for  i←1  to  n  {从 $Y$ 中抽取 $T\}$
• $10.if|x(Y[i])-x_0|⩽\delta then$
• $11.k\leftarrow k+1$
• $12.T[k]\leftarrow Y[i]$
• $13.endif$
• 14.   e n d   f o r    { k \hspace{0.85cm}14.\space\hspace{1cm}end\space for\space\space\{ k 14. end for  {k 是 $T$ 的大小$\}$
• 15.   δ ′ ← 2 δ    { \hspace{0.85cm}15.\space\hspace{1cm}\delta'\leftarrow2\delta\space\space\{ 15. δ′←2δ  {将 ${\delta }^{\prime }$ 初始化为大于 $\delta$ 的值$\}$
• 16.   f o r    i ← 1    t o    k − 1    { \hspace{0.85cm}16.\space\hspace{1cm}for\space\space i\leftarrow1\space\space to\space\space k-1\space\space\{ 16. for  i←1  to  k−1  {计算 ${\delta }^{\prime }\}$
• 17.   f o r    j ← i + 1    t o    min ⁡ { i + 7 , k } \hspace{0.85cm}17.\space\hspace{2cm}for\space\space j\leftarrow i+1\space\space to\space\space\min\{i+7,k\} 17. for  j←i+1  to  min{i+7,k}
• $18.ifd(T[i],T[j])<{\delta }^{\prime }then{\delta }^{\prime }\leftarrow d(T[i],T[j])$
• $19.endfor$
• $20.endfor$
• 21.   δ ← min ⁡ { δ , δ ′ } \hspace{0.85cm}21.\space\hspace{1cm}\delta\leftarrow\min\{\delta,\delta'\} 21. δ←min{δ,δ′}
• $22.endif$
• $23.return\delta$

时间复杂度分析：
易知递推关系式为 $T(n)=\{\begin{array}{l}1ifn=2\\ \\ 3ifn=3\\ \\ 2T(\frac{n}{2})+\Theta (n)ifn>3\end{array}$
$\Rightarrow T(n)=\Theta (n\log n)$