时间复杂度的计算

时间复杂度的计算

概要说明

本文主要简单记录自己在学习数据结构的算法复杂度的过程中，遇到的问题和一些心得体会，便于以后自己参考。

时间复杂度的定义

一个语句的频度是指该语句在算法中被重复执行的次数。算法中所有语句的频度之和记为T(n)，它是该算法问题规模 n 的函数，时间复杂度主要分析 T(n)

的数量级。算法中基本运算 (最深层循环内的语句)的频度与 T(n)同数量级，因此通常采用算法中基本运算的频度f(n))来分析算法的时间复杂度: T(n)=O(f(n))

加法规则

$$T(n)=T_1(n)+T_2(n)=O(f(n))+O(g(n))=O(max(f(n),g(n)))$$

乘法规则

$$T(n)=T_1(n)\times T_2(n)=O(f(n))\times O(g(n))=O(f(n)\times g(n))$$

常见的渐进时间复杂度

$$O(1)<O(log{)}_2^n<O(n)<O(nlo{g}_2^n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)$$

计算时间复杂度的2种通用方法

1 循环主体中的变量参与循环条件的判断

int i = 1;
while(i < n)
    i=i*2;

假设第t次退出循环，每次循环i乘以2，第t次，就是$2^t$，那么有 $2^t<n$，即是：$t<=lo{g}_2^n$，从而时间复杂度是$O(lo{g}_2^n)$

2 循环主体的变量和循环条件无关

此类题可采用数学归纳法或直接累计循环次数。多层循环时从内到外分析，忽略单步语句、条件判断语句，只关注主体语句的执行次数。此类问题又可分为递归程序和非递归程序。递归程序一般使用公公式递推，非递归程序直接累计计数

例题 1

一个算法所需时间由下述递归方程表示，试求出该算法的时间复杂度的级别（或阶）
$$T(n)=\{\begin{array}{ll}1& n=1\\ & \\ 2T(n/2)+n& n>1\end{array}$$

式中，$n$是问题的规模，为简单起见，设$n$是2的整数次幕.

解答如下:

设 $n=2^k$,其中 $k>=0$, 则有
$$T(2^k)=\{\begin{array}{ll}1& k=0\\ & \\ 2T(2^{k-1})+2^k& k>0\end{array}$$
从而，当$k>0$时，$T(2^k)=2T(2^{k-1})+2^k$；用k取k-1得到：
$$T(2^{k-1})=2T(2^{k-2})+2^{k-1}$$
将$（2）$式带入$（1）$有：

$$\begin{array}{rl}T(2^k)& =\begin{array}{rl}& 2(2T(2^{k-2})+2^{k-1})+2^k\end{array}\\ & =2\times 2T(2^{k-2})+2\times 2^{k-1}+2^k\\ & =2\times 2T(2^{k-2})+2\times 2^k\\ & =2^2\times T(2^{k-2})+2\times 2^k\end{array}$$
同样的,用k取k-2，并带入，得到:

​
$$\begin{array}{rl}T(2^k)& =\begin{array}{rl}& 2(2T(2^{k-2})+2^{k-1})+2^k\end{array}\\ & =2\times 2T(2^{k-2})+2\times 2^{k-1}+2^k\\ & =2\times 2T(2^{k-2})+2\times 2^k\\ & =2^2\times T(2^{k-2})+2\times 2^k\\ & =2^2\times (2T(2^{k-2}+2^{k-2}))+2^k\\ & =2^3\times T(2^{k-3})+2^2\times 2^{k-2}+2^k\\ & =2^3\times T(2^{k-3})+3\times 2^k\end{array}$$
​

观察，猜测 $T(2^k)=2^{i}T(2^{k-i})+i\times 2^k$，由于$T(1)=1$，得到 ，$T(2^k)=(1+k)\times 2^k$。用数学归纳法证明:

当k = 0时，$T(1)=(1+0)\times 2^0=1$，成立，假设$k=m,m>0$时，结论成立，则有: $T(2^m)=(1+m)\times 2^m$.

事实上, 当$k=m+1$时,有:

$$\begin{array}{rl}T(2^{m+1})& =\begin{array}{rl}& 2\times T(2^m)+2^{m+1}\end{array}\\ & =2\times ((1+m)\times 2^m)+2^{m+1}\\ & =(1+m)\times 2^{m+1}+2^{m+1}\\ & =(1+(1+m))\times 2^{m+1}\\ & =T(m+1)\end{array}$$
从而猜测的结论成立. 将 $k=lo{g}_2^n$带入，得到:

$$T(n)=\{\begin{array}{ll}1& n=1\\ & \\ n+nlo{g}_2^n& n>1\end{array}$$
于是时间复杂度为: $O(n)+O(nlo{g}_2^n)$ ，取二者较大值：$O(nlo{g}_2^n)$

例题 2

求解斐波那契数列
$$F(n)=\{\begin{array}{ll}1& n=0,1\\ & \\ F(n-1)+F(n-2)& n>1\end{array}$$
有2种常用的算法：递归算法和非递归算法。试分析这两各种算法的时间复杂度。

1. 递归算法：
   递归算法是最简单的方法，但它具有较高的时间复杂度，因为它会重复计算相同的子问题，导致指数级的递归调用。

递归算法的递归关系是：
$F(n)=F(n-1)+F(n-2)$

递归算法的时间复杂度可用递归树来分析。每次递归调用都会分解成两个子问题，每个子问题又会分解成两个子问题，依此类推，直到 n 达到 0 或 1 时停止递归。因此，递归树的深度是 n，而每层的节点数是指数级增长的，约为$2^n$。

因此，递归算法的时间复杂度是指数级的，大约为$O(2^n)$。这使得递归算法在计算较大的斐波那契数时非常低效。

2. 非递归算法（迭代算法）：
   非递归算法采用迭代的方式来计算斐波那契数列，通过保存中间结果来避免重复计算，因此具有更低的时间复杂度。

非递归算法通过从小到大逐个计算斐波那契数，从 $F(0)$ 和$ F(1) $开始，一直计算到 $F(n)$。这个过程只需要一次遍历，每次计算都只涉及前两个斐波那契数，因此时间复杂度是线性的，约为$O(n)$。

总结：

• 递归算法的时间复杂度为$O(2^n)$，指数级增长，非常低效。
• 非递归算法的时间复杂度为$O(n)$，线性增长，效率更高。

因此，通常情况下，推荐使用非递归算法来计算斐波那契数列，特别是在需要计算大数值时，因为它具有更高的效率。递归算法只在教育和理论分析中常常使用，而在实际应用中通常不适用。

总结

计算一个程序的事件复杂度，主要从2方面下手，看循环变量影不影响循环，如果影响，那就从这里入手，直接计算程序的运行次数；如果不影响，那就涉及到递归，需要观察得到递归的通式，来得出程序的时间复杂度。

参考资料

王道 数据结构复习