如果我们想验证一段代码的效率,一个最直接的办法就是编出来之后运行一下,这个方法称为事后统计方法,但是这个方法存在着非常大的弊端,比如我们需要时间编写代码,而代码写完后如果不符合要求需要重新编写;测试的方法会受到硬件和内存占有率的影响等等。所以为了让代码的评估更加规范和科学,我们更多的使用事前分析估计方法,即计算一个代码的时间复杂度。
其实一段代码的时间复杂度计算很容易,它是一种对计算次数的统计,它有如下几条规则:
1.用常数1取代运算次数中所有的加法常数。
2.只保留最高阶的项。
3.将最高阶的项前面的系数换成1.
这个方法被称之为大O阶方法。
我们通过几个例子看一看上述规则到底如何让使用:
O ( 1 ) O(1) O(1)复杂度
int sunm =0,n=100; //执行1次
sum= (1+n)*n/2; //执行1次
printf("%d",sum); //执行1次
上面一段代码一共执行3次,但是时间复杂度是
O
(
3
)
O(3)
O(3)吗?
并不是,因为按照规则1,上述代码的时间复杂度应该是
O
(
1
)
O(1)
O(1)。
hash表的查找就是
O
(
1
)
O(1)
O(1)的时间复杂度。
O ( n ) O(n) O(n)复杂度
int i; //执行1次
for (i = 0;i<n;i++) //执行n+1次
{
printf("%d",i); //执行n次
}
上面一段代码一共执行 2 n + 2 2n+2 2n+2次,按照大O阶方法:
2 n + 2 2n+2 2n+2—> 2 n + 1 2n+1 2n+1—> 2 n 2n 2n—> n n n
上述代码的时间复杂度应该是 O ( n ) O(n) O(n)。就代表数据量增大几倍,耗时也增大几倍,即时间复杂度是线性的,常见的就是如上述代码所示的遍历算法。
O ( n 2 ) O(n^2) O(n2)复杂度
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 + 2 n + 3 n^2+2n+3 n2+2n+3次,按照大O阶方法:
n 2 + 2 n + 3 n^2+2n+3 n2+2n+3—> n 2 + 2 n + 1 n^2+2n+1 n2+2n+1—> n 2 n^2 n2
上述代码的时间复杂度应该是 O ( n 2 ) O(n^2) O(n2),就代表数据量增大n倍时,耗时增大n的平方倍,这是比线性更高的时间复杂度。比如冒泡排序,就是典型的 O ( n 2 ) O(n^2) O(n2)的算法,对n个数排序,需要扫描 n 2 n^2 n2次。
O ( m n ) O(mn) 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
×
n
+
2
n
+
3
m\times n+2n+3
m×n+2n+3次,按照大O阶方法:
m
×
n
+
2
n
+
3
m\times n+2n+3
m×n+2n+3 —>
m
×
n
+
2
n
+
1
m\times n+2n+1
m×n+2n+1 —>
m
×
n
m\times n
m×n
上述代码的时间复杂度应该是 O ( m n ) O(mn) O(mn)。 O ( m n ) O(mn) O(mn)复杂度的典型代表是双层循环,当双重训练的次数相同时, O ( m n ) O(mn) O(mn)等效于 O ( n 2 ) O(n^2) O(n2)。
O ( l o g n ) O(log^n) O(logn)复杂度
int count = 1; //执行1次
while(count<n) //执行k+1次
{
count = count*2; //执行k次
}
上面的k如何计算呢?count 每次乘2,直到不再小于n时退出,所以:
2
k
=
n
2^k=n
2k=n,于是
k
=
l
o
g
2
n
k=log{_{2}}^{n}
k=log2n,所以上述代码共执行
2
l
o
g
2
n
+
2
2log{_{2}}^{n}+2
2log2n+2次,按照大O阶方法:
2 l o g 2 n + 2 2log{_{2}}^{n}+2 2log2n+2—> 2 l o g 2 n + 1 2log{_{2}}^{n}+1 2log2n+1—> 2 l o g 2 n 2log{_{2}}^{n} 2log2n—> l o g 2 n log{_{2}}^{n} log2n
一般情况下, l o g 2 n log{_{2}}^{n} log2n会简写 l o g n log^{n} logn(虽然这种写法在数学上是不对的),所以上述代码的时间复杂度应该是 l o g n log^{n} logn。当数据增大n倍时,耗时增大 l o g n log^{n} logn倍,比如,当数据增大256倍时,耗时只增大8倍,是比线性还要低的时间复杂度)。典型的 l o g n log^{n} logn算法就是二分查找,每找一次排除一半的可能,256个数据中查找只要找8次就可以找到目标。
总结
最后给出常见的执行次数函数与其对应的时间复杂度:
常见时间复杂度排序:
常用数据结构,查找,插入,删除复杂度总结: