时间复杂度的计算

如果我们想验证一段代码的效率，一个最直接的办法就是编出来之后运行一下，这个方法称为事后统计方法，但是这个方法存在着非常大的弊端，比如我们需要时间编写代码，而代码写完后如果不符合要求需要重新编写；测试的方法会受到硬件和内存占有率的影响等等。所以为了让代码的评估更加规范和科学，我们更多的使用事前分析估计方法，即计算一个代码的时间复杂度。
其实一段代码的时间复杂度计算很容易，它是一种对计算次数的统计，它有如下几条规则：
1.用常数1取代运算次数中所有的加法常数。
2.只保留最高阶的项。
3.将最高阶的项前面的系数换成1.
这个方法被称之为大O阶方法。
我们通过几个例子看一看上述规则到底如何让使用：

$O(1)$复杂度

int  sunm =0,n=100;    //执行1次
sum= (1+n)*n/2;        //执行1次
printf("%d",sum);      //执行1次

上面一段代码一共执行3次，但是时间复杂度是$O(3)$吗?
并不是，因为按照规则1，上述代码的时间复杂度应该是$O(1)$。
hash表的查找就是$O(1)$的时间复杂度。

$O(n)$复杂度

int i;                  //执行1次
for (i = 0;i<n;i++)     //执行n+1次
{
  printf("%d",i);       //执行n次
}

上面一段代码一共执行$2n+2$次，按照大O阶方法：

$2n+2$—>$2n+1$—>$2n$—>$n$

上述代码的时间复杂度应该是$O(n)$。就代表数据量增大几倍，耗时也增大几倍，即时间复杂度是线性的，常见的就是如上述代码所示的遍历算法。

$O(n^2)$复杂度

int i,j;                //执行1次
for (i = 0;i<n;i++)     //执行n+1次
{
	for (j = 0;j<n;i++) //执行n+1次
	{
		printf("%d",i);   //执行n*n次
	}	
}

上面一段代码一共执行$n^2+2n+3$次，按照大O阶方法：

$n^2+2n+3$—>$n^2+2n+1$—>$n^2$

上述代码的时间复杂度应该是$O(n^2)$，就代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。比如冒泡排序，就是典型的$O(n^2)$的算法，对n个数排序，需要扫描$n^2$次。

$O(mn)$复杂度

int i,j;                //执行1次
for (i = 0;i<n;i++)     //执行n+1次
{
	for (j = 0;j<m;i++) //执行n+1次
	{
		printf("%d",i);   //执行n*m次
	}	
}

上面一段代码一共执行$m\times n+2n+3$次，按照大O阶方法：
$m\times n+2n+3$ —> $m\times n+2n+1$ —>$m\times n$

上述代码的时间复杂度应该是$O(mn)$。$O(mn)$复杂度的典型代表是双层循环，当双重训练的次数相同时，$O(mn)$等效于$O(n^2)$。

$O(lo{g}^n)$复杂度

int count = 1;     //执行1次
while(count<n)   //执行k+1次
{
	count = count*2;  //执行k次
}

上面的k如何计算呢？count 每次乘2，直到不再小于n时退出，所以：
$2^k=n$，于是$k=log{{}_2}^n$，所以上述代码共执行$2log{{}_2}^n+2$次，按照大O阶方法：

$2log{{}_2}^n+2$—>$2log{{}_2}^n+1$—>$2log{{}_2}^n$—>$log{{}_2}^n$

一般情况下，$log{{}_2}^n$会简写$lo{g}^n$（虽然这种写法在数学上是不对的），所以上述代码的时间复杂度应该是$lo{g}^n$。当数据增大n倍时，耗时增大$lo{g}^n$倍，比如，当数据增大256倍时，耗时只增大8倍，是比线性还要低的时间复杂度）。典型的$lo{g}^n$算法就是二分查找，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标。

总结

最后给出常见的执行次数函数与其对应的时间复杂度：

常见时间复杂度排序：

常用数据结构，查找，插入，删除复杂度总结：