算法分析的魔力背后是否有一个系统？

关于如何分析算法的运行时间存在很多问题（例如，参见运行时分析和算法分析）。许多都是类似的，例如那些要求对嵌套循环或分而治之算法进行成本分析的方法，但是大多数答案似乎都是量身定制的。

另一方面，另一个通用问题的答案通过一些示例解释了更大的图景（尤其是关于渐近分析），但没有说明如何弄脏您的手。

有没有一种结构化的，通用的方法来分析算法的成本？成本可能是运行时间（时间复杂度），也可能是某种其他成本度量，例如执行的比较次数，空间复杂度或其他。

^{这应该成为一个参考问题，可以用来指导初学者。因此其范围比平常大。请小心给出一般的，有说服力的答案，至少由一个示例说明了这一点，但仍然涵盖了许多情况。谢谢！}

将代码翻译成数学

给定（或多或少）形式化的操作语义，您可以将算法的（伪）代码从字面上转换为可以为您提供结果的数学表达式，前提是您可以将表达式操纵为有用的形式。这对于附加成本度量（例如比较数，交换，语句，内存访问，某些抽象机需求的循环等等）非常有效。

示例：Bubblesort中的比较

考虑以下对给定数组进行排序的算法A：

 bubblesort(A) do                   1
  n = A.length;                     2
  for ( i = 0 to n-2 ) do           3
    for ( j = 0 to n-i-2 ) do       4
      if ( A[j] > A[j+1] ) then     5
        tmp    = A[j];              6
        A[j]   = A[j+1];            7
        A[j+1] = tmp;               8
      end                           9
    end                             10
  end                               11
end                                 12

假设我们要执行通常的排序算法分析，即计算元素比较的次数（第5行）。我们立即注意到，该数量不取决于数组的内容A，而仅取决于其长度。这样我们就可以将（嵌套的）循环完全转换为（嵌套的）和。循环变量变为求和变量，范围继续。我们得到：$n$for

，$\qquad\displaystyle C_{\text{cmp}}(n) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \dots = \frac{n(n-1)}{2} = \binom{n}{2}$

其中是第5行（我们计算）的每次执行费用。$1$

示例：在Bubblesort中交换

我将表示，它由线的子程序，以和由Ç 我，Ĵ用于执行该子程序（一次）的费用。$P_{i,j}$ij$C_{i,j}$

现在，让我们说，我们要算掉，那是多么经常执行。这是一个“基本块”，它是一个子程序，始终以原子方式执行并具有一定的成本（此处为1）。压缩这样的块是一种有用的简化，我们经常在不考虑或谈论它的情况下就应用它。$P_{6,8}$$1$

通过与上述类似的翻译，我们得出以下公式：

。$\qquad\displaystyle C_{\text{swaps}}(A) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

表示前阵列的状态（我，Ĵ ）的次迭代 P 5 ，9。$A^{(i,j)}$$(i,j)$$P_{5,9}$

请注意，我使用而不是n作为参数。我们很快就会明白原因。我不加我和Ĵ作为参数Ç 5 ，9，因为成本不依赖于他们在这里（在统一的成本模型，这是）; 一般来说，他们只是可能。$A$$n$$i$$j$$C_{5,9}$

显然，成本取决于内容甲（值和，特别是），所以我们必须考虑到这一点。现在我们面临一个挑战：我们如何“解包” Ç 5 ，9？好吧，我们可以使对A内容的依赖关系明确：$P_{5,9}$$A$A[j]A[j+1]$C_{5,9}$$A$

。$\qquad\displaystyle C_{5,9}(A^{(i,j)}) = C_5(A^{(i,j)}) + \begin{cases} 1 &, \mathtt{A^{(i,j)}[j] > A^{(i,j)}[j+1]} \\ 0 &, \text{else} \end{cases}$

对于任何给定的输入数组，这些成本是明确定义的，但是我们需要更笼统的说明；我们需要做出更强有力的假设。让我们研究三种典型的情况。

1. 最坏的情况

   刚刚从看总和并注意到，我们可以找到一个微不足道的上限费用：$C_{5,9}(A^{(i,j)}) \in \{0,1\}$

   。$\qquad\displaystyle C_{\text{swaps}}(A) \leq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \frac{n(n-1)}{2} = \binom{n}{2}$

   但是会发生这种情况吗，即达到该上限的？事实证明，是的：如果我们输入成对的不同元素的反向排序数组，则每次迭代都必须执行一次交换¹。因此，我们得出了Bubblesort交换的最坏情况的确切数字。$A$

2. 最好的情况

   相反，有一个小的下限：

   。$\qquad\displaystyle C_{\text{swaps}}(A) \geq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 0 = 0$

   这也可能发生：在已排序的数组上，Bubblesort不会执行单个交换。

3. 平均情况

   最坏的情况和最好的情况还存在很大差距。但是掉期的典型数量是多少？为了回答这个问题，我们需要定义“典型”的含义。从理论上讲，我们没有理由偏爱一个输入而不是另一个输入，因此我们通常假定所有可能输入的分布均匀，即每个输入均具有相同的可能性。我们将自己限制为具有成对的不同元素的数组，因此采用随机排列模型。

   然后，我们可以像这样重写我们的费用²：

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

   现在我们必须超越简单的求和运算。通过查看算法，我们注意到，每一个交换去除只有一个倒置在（我们永远只能换neighbours³）。也就是说，在执行交换次数甲正是反转次数INV （甲）的甲。因此，我们可以替换内部的两个和得到$A$$A$$\operatorname{inv}(A)$$A$

   。$\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \operatorname{inv}(A)$

   对我们来说幸运的是，平均反演次数已确定为

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{2} \cdot \binom{n}{2}$

   这是我们的最终结果。请注意，这恰好是最坏情况下成本的一半。

1. 请注意，算法是经过精心制定的，因此i = n-1不会执行从未执行任何操作的外部循环的“最后一次”迭代。
2. “ ”是“期望值”的数学符号，这里只是平均值。$\mathbb{E}$
3. 我们沿途学习，没有一种仅交换相邻元素的算法在渐近性上可以比Bubblesort渐近地快（甚至是平均水平）-求反的次数是所有此类算法的下限。这适用于例如插入排序和选择排序。

通用方法

在示例中我们已经看到，我们必须将控制结构转换为数学。我将介绍翻译规则的典型合奏。我们还已经看到，任何给定子程序的成本可能取决于当前状态，即（大致而言）变量的当前值。由于该算法（通常）会修改状态，因此通用方法要注释起来有点麻烦。如果您开始感到困惑，建议您回到该示例或自己编写示例。

我们用表示当前状态（将其想象为一组变量赋值）。当我们执行从状态ψ开始的程序时，我们以状态ψ / P结束（提供终止）。$\psi$P$\psi$$\psi / \mathtt{P}$P

• 个人陈述

  仅给出一个语句S;，就将其分配为。这通常是一个常数函数。$C_S(\psi)$

• 表达方式

  如果您具有E形式的表达式E1 ∘ E2（例如，算术表达式，其中∘可能是加法或乘法），则需要递归累加成本：

  。$\qquad\displaystyle C_E(\psi) = c_{\circ} + C_{E_1}(\psi) + C_{E_2}(\psi)$

  注意

  • 操作成本可以不是恒定的，而是依赖于值ë 1和ë 2和$c_{\circ}$$E_1$$E_2$
  • 评估表达式可能会改变许多语言的状态，

  因此您可能必须对这个规则保持灵活。

• 序列

  给定一个程序P作为程序序列Q;R，您将成本添加到

  。$\qquad\displaystyle C_P(\psi) = C_Q(\psi) + C_R(\psi / \mathtt{Q})$

• 有条件的

  给定P形式的程序if A then Q else R end，费用取决于状态：

  $\qquad\displaystyle C_P(\psi) = C_A(\psi) + \begin{cases} C_Q(\psi/\mathtt{A}) &, \mathtt{A} \text{ evaluates to true under } \psi \\ C_R(\psi/\mathtt{A}) &, \text{else} \end{cases}$

  通常，评估A可能会很好地改变状态，因此会更新各个分支机构的成本。

• 循环

  给定P形式的程序for x = [x1, ..., xk] do Q end，分配成本

  $\qquad\displaystyle C_P(\psi) = c_{\text{init_for}} + \sum_{i=1}^k c_{\text{step_for}} + C_Q(\psi_i \circ \{\mathtt{x := xi\}})$

  其中是处理前的状态为值与迭代之后，即，被设置为，...， 。$\psi_i$Qxixx1xi-1

  注意用于循环维护的额外常量；必须创建循环变量（）并为其赋值（c step_for）。这很重要，因为$c_{\text{init_for}}$$c_{\text{step_for}}$

  • 计算下一个xi可能会很昂贵，并且
  • for如果执行迭代，则具有空主体的-loop（例如，在使用最佳成本的最佳情况下进行简化后）不会具有零成本。

• 循环

  给定P形式的程序while A do Q end，分配成本

  $\qquad\displaystyle C_P(\psi) \\\qquad\ = C_A(\psi) + \begin{cases} 0 &, \mathtt{A} \text{ evaluates to false under } \psi \\ C_Q(\psi/\mathtt{A}) + C_P(\psi/\mathtt{A;Q}) &, \text{ else} \end{cases}$

  通过检查算法，这种重复经常可以很好地表示为类似于for循环的总和。

  示例：考虑以下简短算法：

  while x > 0 do    1
    i += 1          2
    x = x/2         3
  end               4
  

  通过应用规则，我们得到

  $\qquad\displaystyle C_{1,4}(\{i := i_0; x := x_0\}) \\\qquad\ = c_< + \begin{cases} 0 &, x_0 \leq 0 \\ c_{+=} + c_/ + C_{1,4}(\{i := i_0 + 1; x := \lfloor x_0/2 \rfloor\}) &, \text{ else} \end{cases}$

  $c_{\dots}$ix

  $C_{1,4}$i

  $\qquad\displaystyle C_{1,4}(x) = \begin{cases} c_> &, x \leq 0 \\ c_> + c_{+=} + c_/ + C_{1,4}(\lfloor x/2 \rfloor) &, \text{ else} \end{cases}$

  这解决了基本的手段来

  $\qquad\displaystyle C_{1,4}(\psi) = \lceil \log_2 \psi(x) \rceil \cdot (c_> + c_{+=} + c_/) + c_>$

  $\psi = \{ \dots, x := 5, \dots\}$$\psi(x) = 5$

• 程序调用

  给定某个参数P形式的程序，其中是带有（命名）参数的过程，请分配费用M(x)xMp

  $\qquad\displaystyle C_P(\psi) = c_{\text{call}} + C_M(\psi_{\text{glob}} \circ \{p := x\})$

  $c_{\text{call}}$$\psi$

  我掩盖了您可能会对此处的状态产生的一些语义问题。您将要区分全局状态和过程调用的局部状态。假设我们仅在此处传递全局状态，并M获得一个新的局部状态，方法是将的值设置p为x。此外，x可能是一个表达式，我们（通常）假定在传递它之前先对其求值。

  示例：考虑程序

  fac(n) do                  
    if ( n <= 1 ) do         1
      return 1               2
    else                     3
      return n * fac(n-1)    4
    end                      5
  end                        
  

  根据规则，我们得到：

  $\qquad\displaystyle\begin{align*} C_{\text{fac}}(\{n := n_0\}) &= C_{1,5}(\{n := n_0\}) \\ &= c_{\leq} + \begin{cases} C_2(\{n := n_0 \}) &, n_0 \leq 1 \\ C_4(\{n := n_0 \}) &, \text{ else} \end{cases} \\ &= c_{\leq} + \begin{cases} c_{\text{return}} &, n_0 \leq 1 \\ c_{\text{return}} + c_* + c_{\text{call}} + C_{\text{fac}}(\{n := n_0 - 1\}) &, \text{ else} \end{cases} \end{align*}$

  请注意，我们无视全局状态，因为fac显然不访问任何状态。这种特定的复发很容易解决

  $\qquad\displaystyle C_{\text{fac}}(\psi) = \psi(n) \cdot (c_{\leq} + c_{\text{return}}) + (\psi(n) - 1) \cdot (c_* + c_{\text{call}})$

我们已经介绍了典型伪代码中将遇到的语言功能。分析高级伪代码时要注意隐藏的成本；如有疑问，请展开。这个符号看起来很麻烦，而且肯定是一个品味问题。但是，不能忽略列出的概念。但是，有了一些经验，您将能够立即看到状态的哪个部分与哪种成本度量相关，例如“问题大小”或“顶点数”。其余的可以删除-这大大简化了事情！

如果您现在认为这太复杂了，建议您：是！很难在任何与真实机器非常接近的模型中得出算法的确切成本，以使得能够进行运行时预测（甚至是相对的预测）也是一项艰巨的努力。而且，这甚至都没有考虑在实际计算机上进行缓存和其他令人讨厌的影响。

因此，算法分析通常简化到数学上易于处理的程度。例如，如果您不需要确切的成本，则可以在任何时候高估或低估（上限或下限）：减少常量集，摆脱条件，简化总和，等等。

关于渐近成本的注记

$n$

这是（通常）公平的，因为根据机器，操作系统和其他因素，抽象语句实际上会带来一些（通常是未知的）成本，并且较短的运行时间可能由操作系统首先设置进程来决定，而并非如此。因此，无论如何，您都会感到不安。

渐近分析与这种方法的关系如下。

1. 确定主要操作（产生成本），即最常发生的操作（取决于恒定因素）。在Bubblesort示例中，一种可能的选择是第5行的比较。

   或者，通过基本运算的最大值（从上方）约束所有常量的基本运算。他们的最小值（从下面开始）并执行通常的分析。

2. 使用此操作的执行计数作为成本执行分析。
3. $O$$\Omega$

$O$

进一步阅读

算法分析中还有许多挑战和技巧。这是一些推荐的读物。

• 如何提出算法的运行时间？
  如何描述算法，证明和分析算法？
• 为什么要使用比较而不是运行时来比较两种算法？
  我们如何假设对数字的基本运算需要固定的时间？
  在运行时分析中，什么构成一个时间单位？
• 求解或近似数字序列的递归关系
• 摊销分析基础

围绕着使用类似技术的标记算法分析存在很多问题。

语句的执行计数

还有另一种方法，由Donald E. Knuth在他的《计算机编程艺术》中提出系列中。与之相反将整个算法转换为一个公式，它在“将事物放在一起”方面独立于代码的语义运行，并且仅在必要时才从“鹰眼”视图进入较低的层次。每个语句均可独立于其余语句进行分析，从而使计算更加清晰。但是，该技术非常适合于相当详细的代码，而不是更高级的伪代码。

方法

原理上很简单：

1. 为每个语句分配一个名称/编号。
2. $S_i$$C_i$。
3. $S_i$$e_i$。

4. 计算总费用

   $\qquad\displaystyle C = \sum_{i} e_i \cdot C_i$

您可以随时插入估算值和/或符号数量，从而削弱响应能力。相应地推广结果。

$e_{77} \in O(n \log n)$

示例：深度优先搜索

考虑以下图遍历算法：

dfs(G, s) do
  // assert G.nodes contains s
  visited = new Array[G.nodes.size]     1
  dfs_h(G, s, visited)                  2
end 

dfs_h(G, s, visited) do
  foo(s)                                3
  visited[s] = true                     4

  v = G.neighbours(s)                   5
  while ( v != nil ) do                 6
    if ( !visited[v] ) then             7
      dfs_h(G, v, visited)              8
    end
    v = v.next                          9
  end
end

$\{0,\dots,n-1\}$$m$为边数。

$A$$B$$C$$e_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & A & A & B & B & B & B+C & C & B-1 & C \end{array}$

$e_8 = e_3-1$foodfs$e_6 = e_5 + e_7$while

$A=1$foo$B = n$$C = 2m$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & 1 & 1 & n & n & n & 2m + n & 2m & n-1 & 2m \end{array}$

这导致我们的总成本为

$\qquad\begin{align*} C(n,m) = (C_1 + C_2 - C_8) &+\ n \cdot (C_3 + C_4 + C_5 + C_6 + C_8) \\ &+\ 2m \cdot (C_6 + C_7 + C_9) \;. \end{align*}$

$C_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline C_i & n & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 \end{array}$

并得到

$\qquad\displaystyle C_{\text{mem}}(n,m) = 3n + 4m$

进一步阅读

请参阅我的其他答案的底部。

像定理证明一样，算法分析在很大程度上是一门艺术（例如，有些简单的程序（例如Collat​​z问题）我们不知道如何进行分析）。我们可以将算法复杂性问题转换为数学问题，正如Raphael全面回答的那样，但是为了用已知函数表达算法成本的界限，我们不得不：

1. 使用从现有分析中获知的技术，例如根据我们了解的重复数或求和/积分我们可以计算出的范围。
2. 将算法更改为我们知道如何分析的算法。
3. 提出一种全新的方法。