算法复杂度（时间复杂度）

之前没正式接触过算法，突然面对算法复杂度的计算，作为小白有点蒙，查阅众多资料和博客后做以下笔记。

来源：百度百科
算法复杂度是指算法在编写成可执行程序后，运行时所需要的资源，资源包括时间资源和内存资源。应用于数学和计算机导论。
同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。一个算法的评价主要从时间复杂度和空间复杂度来考虑。

1、关于一些符号表示

n、T(n)、f(n): n为问题的规模，T(n)是一个算法中的语句执行次数称为语句频度或时间频度。当n不断变化时，时间频度T(n)也会不断变化。一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),存在一个正常数c使得f(n)*c>=T(n)恒成立。记作T(n)=O(f(n)),说明在趋向无穷的极限意义下，函数T(n)的增长速度受到f的约束，f是g的渐进函数。O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

2、最基本的遵循规则 （顺序组合、条件分支和循环结构）

0. 基本操作，认为其时间复杂度为O(1)。如果是函数调用，应该将其时间复杂度代入，参与整体i时间复杂度的计算。
   实例：
   无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)，如：

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

2. 加法规则（顺序复合）。如果算法（或所考虑算法片段）是两个部分（或多个部分）的顺序复合，其复杂性是这两部分（或多部分）的复杂性之和。以两个部分为例：
   $$T(n)=T1(n)+T2(n)=O(T1(n))+O(T2(n))=O(max(T1(n),T2(n)))$$
   其中T1(n) 、T2(n)分别为顺序复合的两个部分的时间复杂度。由于忽略了常量因子，加法等价于求最大值，取T1(n)和T2(n)中复杂度较高的一个。
   实例：

for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度。

2. 乘法规则（循环结构）。如果算法（或所考虑算法片段）是一个循环，循环体将执行T1(n)次，每次执行需要T2(n)时间，那么：
   $T(n)=T1(n)\times$ T2(n)= O(T1(n))$\times$ O(T2(n))=O(T1(n)$\times$ T2(n))
3. 取最大规则（分支结构）。如果算法（或考虑算法片段）是条件分支，两个分支的时间复杂度分别为T1(n)和T2(n)，则有：
   $$T(n)=O(max(T1(n),T2(n)))$$
   综合实例：
   程序片段：求出两个n$\times$n矩阵m1和m2的乘积，存入另一个n$\times$n矩阵m

for i in range(n):
    for j in range(n):
        x = 0.0
        for k in range(n):
            x = x + ml[i][k] * m2[k][j]
        m[i][x] = x  

这个程序片段是一个两重循环，循环体是一个顺序语句，其中还有一个内嵌的循环。根据复杂度计算规则，可以做以下推导：

$T(n)=O(n)\times O(n)\times (O(1)+O(n)\times$O(1)+O(1) )
$=O(n)\times O(n)\times O(n)$
$=O(n\times n\times n)$
$=O(n^3)$
其中$(O(1)+O(n)\times$O(1)+O(1) )部分表示循环体的复杂度，包括两个基本的语句和一个简单的循环体，化简后可得O(n)

3、最常用的渐进复杂度函数

$O(1)$、$O(logn)$、$O(n)$、$O(nlogn)$、$O(n^2)$、$O(n^3)$、$O(2^n)$

对数阶（$O(logn)$）

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

从上面代码可以看到，在while循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。我们试着求解一下，假设循环x次之后，i 就大于 2 了，此时这个循环就退出了，也就是说 2 的 x 次方等于 n，那么 $x=log{2}^n$这个代码就结束了。因此这个代码的时间复杂度为：O(logn)

线性对数阶（$nlogn$）

线性对数阶$O(nlogn)$ 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * $O(logn)$，也就是了$O(nlogn)$。

for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 2;
    }
}

4、递归算法的复杂度

[递归时间复杂度终结篇]
(https://blog.csdn.net/w36680130/article/details/81535128)

References:
(https://blog.csdn.net/jsjwk/article/details/84315770)