如何描述算法，证明和分析算法？

在阅读计算机编程艺术（TAOCP）之前，我没有深入考虑这些问题。我将使用伪代码来描述算法，理解算法并仅估计增长顺序的运行时间。该TAOCP彻底改变了我的脑海里。

TAOCP使用英语加上步骤和goto来描述算法，并使用流程图更轻松地描绘算法。似乎是低级的，但是我发现有一些优点，尤其是流程图，我已经忽略了很多。我们可以在计算遍历该箭头时用关于当前事务状态的断言标记每个箭头，并为该算法提供归纳证明。作者说：

作者的争论是我们真正理解为什么只有当我们达到了我们的思想隐含地填充所有断言的程度时算法才是有效的方法，如图4所示。

我还没有经历过这样的东西。另一个优点是，我们可以计算每个步骤执行的次数。用基尔霍夫的第一定律很容易检查。我没有精确地分析运行时间，因此在估算运行时间时可能会省略一些。$\pm1$

分析增长顺序有时是无用的。例如，由于它们都是，因此我们无法区分quicksort和heapsort ，其中是期望的随机变量，因此我们应该分析常数，例如，和，因此我们可以比较和更好。而且，有时我们应该比较其他数量，例如方差。仅对运行时间的增长顺序进行粗略分析是不够的。作为TAOCP$E(T(n))=\Theta(n\log n)$$EX$$X$$E(T_1(n))=A_1n\lg n+B_1n+O(\log n)$$E(T_2(n))=A_2\lg n+B_2n+O(\log n)$$T_1$$T_2$ 将算法翻译成汇编语言并计算运行时间，这对我来说太难了，所以我想知道一些技术来更粗略地分析运行时间，这对于C，C ++等高级语言也很有用或伪代码。

我想知道研究工作中主要使用哪种描述风格，以及如何处理这些问题。

有许多可行的方法。哪个最适合取决于

• 什么，你都试图表明，
• 您想要或需要多少细节。

如果该算法是众所周知的算法，并且您将其用作子例程，则通常会处于较高级别。如果算法是研究的主要对象，则可能需要更详细地说明。对于分析也可以这样说：如果您需要一个大致的运行时上限，则与需要精确的语句计数时的处理方法不同。

我将为您提供三个著名算法Mergesort的示例，这些示例有望说明这一点。

高水平

Mergesort算法获取一个列表，将其分成两个（大约）等长的部分，在这些部分列表上递归，然后合并（排序的）结果，以便对最终结果进行排序。在单例或空列表上，它返回输入。

该算法显然是正确的排序算法。拆分列表并合并列表可以分别在时间，这使我们可以重现最坏情况下的运行时。根据Master定理，这等于。T （n ）= 2 T （$\Theta(n)$$T(n) = 2T\left(\frac{n}{2}\right) + \Theta(n)$$T(n) \in \Theta(n\log n)$

中级

Mergesort算法由以下伪代码给出：

procedure mergesort(l : List) {
  if ( l.length < 2 ) {
    return l
  }

  left  = mergesort(l.take(l.length / 2)
  right = mergesort(l.drop(l.length / 2)
  result = []

  while ( left.length > 0 || right.length > 0 ) {
    if ( right.length == 0 || (left.length > 0 && left.head <= right.head) ) {
      result = left.head :: result
      left = left.tail
    }
    else {
      result = right.head :: result
      right = right.tail
    }
  }

  return result.reverse
}

通过归纳证明正确性。对于长度为零或一的列表，该算法非常正确。作为归纳假设，对于某些任意但固定的自然，假设mergesort在长度最大为列表上正确执行。现在让为长度为的列表。通过归纳假设，并保持（递减）排序的第一个响应版本。递归调用后后半部分。因此，循环在每次迭代中选择尚未调查的最小元素，并将其附加到；因此是一个非递增排序的列表，其中包含和中的所有元素n > 1 $n$$n>1$$L$大号$n+1$leftright$L$whileresultresultleftright。反向是的非递减排序版本，它是返回的-期望的-结果。$L$

对于运行时，让我们计算元素比较和列表操作（渐近地主导运行时）。长度小于2的列表均不会导致这种情况。对于长度为列表，我们进行了一些操作，这些操作是通过为递归调用准备输入而引起的，这些操作来自递归调用本身加上循环和one 。两个递归参数每个最多可以使用列表操作来计算。该循环正好执行了次，每次迭代最多导致一个元素比较和正好两个列表操作。最终可以实现使用n n 2 $n>1$whilereverse$n$while$n$reverse$2n$列表操作-将每个元素从输入中删除并放入输出列表中。因此，操作计数满足以下重复发生：

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq T\left(\left\lceil\frac{n}{2}\right\rceil\right) + T\left(\left\lfloor\frac{n}{2}\right\rfloor\right) + 7n\end{align}$

由于明显不减小，因此对于渐近增长，考虑就足够了。在这种情况下，重复发生简化为n = 2 $T$$n=2^k$

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq 2T\left(\frac{n}{2}\right) + 7n\end{align}$

通过Master定理，我们得到，它扩展到的运行时。$T \in \Theta(n \log n)$mergesort

超低水平

考虑一下Isabelle / HOL中的Mergesort的（广义）实现：

types dataset  =  "nat * string"

fun leq :: "dataset \<Rightarrow> dataset \<Rightarrow> bool" where
   "leq (kx::nat, dx) (ky, dy) = (kx \<le> ky)"

fun merge :: "dataset list \<Rightarrow> dataset list \<Rightarrow> dataset list" where
"merge [] b = b" |
"merge a [] = a" |
"merge (a # as) (b # bs) = (if leq a b then a # merge as (b # bs) else b # merge (a # as) bs)"

function (sequential) msort :: "dataset list \<Rightarrow> dataset list" where
  "msort []  = []" |
  "msort [x] = [x]" |
  "msort l   = (let mid = length l div 2 in merge (msort (take mid l)) (msort (drop mid l)))"
by pat_completeness auto
  termination
  apply (relation "measure length")
by simp+

这已经包括明确定义和终止的证明。在此处找到（几乎）完整的正确性证明。

对于“运行时”，即比较次数，可以设置与上一节中类似的重复。除了使用Master定理并忽略常量之外，您还可以对其进行分析，以获得近似渐近等于真实量的近似值。您可以在[1]中找到完整的分析；这是一个粗略的轮廓（不一定适合Isabelle / HOL代码）：

如上所述，比较次数的重复次数为

$\qquad \begin{align}f_0 = f_1 &= 0 \\ f_n &= f_{\left\lceil\frac{n}{2}\right\rceil} + f_{\left\lfloor\frac{n}{2}\right\rfloor} + e_n\end{align}$

其中是合并部分结果所需的比较次数²。为了摆脱地板和天花板，我们对是否为偶数进行了区分：$e_n$$n$

$\qquad \displaystyle \begin{cases} f_{2m} &= 2f_m + e_{2m} \\ f_{2m+1} &= f_m + f_{m+1} + e_{2m+1} \end{cases}$

使用和嵌套前向/后向差异，我们得到$f_n$$e_n$

$\qquad \displaystyle \sum\limits_{k=1}^{n-1} (n-k) \cdot \Delta\kern-.2em\nabla f_k = f_n - nf_1$。

该和与Perron公式的右边匹配。我们定义狄氏产生串联的为$\Delta\kern-.2em\nabla f_k$

$\qquad \displaystyle W(s) = \sum\limits_{k\geq 1} \Delta\kern-.2em\nabla f_k k^{-s} = \frac{1}{1-2^{-s}} \cdot \underbrace{\sum\limits_{k \geq 1} \frac{\Delta\kern-.2em\nabla e_k}{k^s}}_{=:\ \boxminus(s)}$

加上Perron的公式，我们可以

$\qquad \displaystyle f_n = nf_1 + \frac{n}{2\pi i} \int\limits_{3-i\infty}^{3+i\infty} \frac{\boxminus(s)n^s}{(1-2^{-s})s(s+1)}ds$。

评价取决于被分析这种情况下。除此之外，我们可以-经过一些欺骗之后-应用残差定理来获得$\boxminus(s)$

$\qquad \displaystyle f_n \sim n \cdot \log_2(n) + n \cdot A(\log_2(n)) + 1$

其中是周期函数，其值在。$A$$[-1,-0.9]$

1. 梅林变换和渐近性：Flajolet和Golin（1992）的mergesort重现
2. 最佳情况： 最坏情况： 平均情况：ËÑ=ñ-1个Ëñ=ñ$e_n = \left\lfloor\frac{n}{2}\right\rfloor$
   $e_n = n-1$
   $e_n = n - \frac{\left\lfloor\frac{n}{2}\right\rfloor}{\left\lceil\frac{n}{2}\right\rceil + 1} - \frac{\left\lceil\frac{n}{2}\right\rceil}{\left\lfloor\frac{n}{2}\right\rfloor + 1}$

迪杰斯特拉（Dijkstra）的“编程学科”就是关于分析和证明算法以及为可证明性进行设计。在该书的序言中，Dijkstra解释了一种经过适当设计以进行分析的非常简单的构造型迷你语言如何足以正式解释许多算法：

当开始这样的书时，会立即面临一个问题：“我将使用哪种编程语言？”，而这不是只是一个介绍问题！任何工具最重要但也是最难以捉摸的方面是它对那些训练使用它的人的习惯的影响。如果该工具是一种编程语言，那么无论我们是否喜欢，这种影响都会对我们的思维习惯产生影响。据我所知，对这种影响进行了分析，得出的结论是，现有的编程语言或它们的子集都不适合我的目的。另一方面，我知道自己还没有为新的编程语言设计做准备，以至于我发誓在接下来的五年中不要这样做，而且我有一个最明显的感觉，那就是那段时期还没有过去！（在此之前，必须撰写本专着。

后来，他解释了自己如何获得了迷你语言。

我欠读者一个解释，为什么我将迷你语言保持得如此之小以至于它甚至不包含过程和递归。…… 重点是，我认为不需要它们来传达我的信息，即。精心选择的关注点分离对于设计各个方面的高质量程序是至关重要的；迷你语言的适度工具已经为我们提供了足够的自由度，可以进行非平凡但非常令人满意的设计。