时间复杂度:如果一个问题的规模是 n ,解这一问题的某一算法所需要的时间为 T(n) ,它是 n 的某一函数, T(n) 称为这一算法的“时间复杂度”。
渐近时间复杂度:当输入量 n 逐渐加大时,时间复杂性的极限情形称为算法的“渐近时间复杂度”。
当我们评价一个算法的时间性能时,主要标准就是算法的渐近时间复杂度,因此,在算法分析时,往往对两者不予区分,经常是将渐近时间复杂度 T(n)=O(f(n)) 简称为时间复杂度,其中的 f(n) 一般是算法中频度最大的语句频度。
此外,算法中语句的频度不仅与问题规模有关,还与输入实例中各元素的取值相关。但是我们总是考虑在最坏的情况下的时间复杂度。以保证算法的运行时间不会比它更长。
常见的时间复杂度,按数量级递增排列依次为:常数阶 O(1) 、对数阶 O(log2n) 、线性阶 O(n) 、线性对数阶 O(nlog2n) 、平方阶 O(n^2) 、立方阶 O(n^3) 、 k 次方阶 O(n^k) 、指数阶 O(2^n) 。
下面我们通过例子加以说明,让大家碰到问题时知道如何去解决。
1 、设三个函数 f,g,h 分别为 f(n)=100n^3+n^2+1000 , g(n)=25n^3+5000n^2 , h(n)=n^1.5+5000nlgn
请判断下列关系是否成立:
( 1 ) f(n)=O(g(n))
( 2 ) g(n)=O(f(n))
( 3 ) h(n)=O(n^1.5)
( 4 ) h(n)=O(nlgn)
这 里我们复习一下渐近时间复杂度的表示法 T(n)=O(f(n)) ,这里的 "O" 是数学符号,它的严格定义是 " 若 T(n) 和 f(n) 是定义在正整数集合上的 两个函数,则 T(n)=O(f(n)) 表示存在正的常数 C 和 n0 , 使得当 n ≥ n0 时都满足 0 ≤ T(n) ≤ C?f(n) 。 " 用容易理解的话说就是这两个函数当整型自变量 n 趋向于无穷大时,两者的比值是一个不等于 0 的常 数。这么一来,就好计算了吧。
◆ (1) 成立。题中由于两个函数的最高次项都是 n^3, 因此当 n →∞时,两个函数的比值是一个常数,所以这个关系式是成立的。
◆ ( 2 )成立。与上同理。
◆ ( 3 )成立。与上同理。
◆ ( 4 )不成立。由于当 n →∞时 n^1.5 比 nlgn 递增的快,所以 h(n) 与 nlgn 的比值不是常数,故不成立。
2 、设 n 为正整数,利用大 "O" 记号,将下列程序段的执行时间表示为 n 的函数。
(1) i=1; k=0
while(i<n)
{ k=k+10*i;i++;
}
解答: T(n)=n-1 , T(n)=O(n) , 这个函数是按线性阶递增的。
(2) x=n; // n>1
while (x>=(y+1)*(y+1))
y++;
解答: T(n)=n1/2 , T(n)=O(n1/2) , 最坏的情况是 y=0 ,那么循环的次数是 n1/2 次,这是一个按平方根阶递增的函数。
(3) x=91; y=100;
while(y>0)
if(x>100)
{x=x-10;y--;}
else x++;
解答: T(n)=O(1) , 这个程序看起来有点吓人,总共循环运行了 1000 次,但是我们看到 n 没有 ? 没。这段程序的运行是和 n 无关的,就算它再循环一万年,我们也不管他,只是一个常数阶的函数。
3. 常数阶 O(1)
Temp=i;i=j;j=temp;
以上三条单个语句的频度均为 1 ,该程序段的执行时间是一个与问题规模 n 无关的常数。算法的时间复杂度为常数阶,记作 T(n)=O(1) 。如果算法的执行时 间不随着问题规模 n 的增加而增长,即使算法中有上千条语句,其执行时间也不过是一个较大的常数。此类算法的时间复杂度是 O(1) 。
4. 平方阶 O(n^2)
( 1 ) 交换 i 和 j 的内容
sum=0 ; (一次)
for(i=1;i<=n;i++) ( n 次 )
for(j=1;j<=n;j++) ( n^2 次 )
sum++ ; ( n^2 次 )
解: T(n)=2n^2+n+1 =O(n^2)
( 2 )
for (i=1;i<n;i++)
{
y=y+1; ①
for (j=0;j<=(2*n);j++)
x++; ②
}
解: 语句 1 的频度是 n-1
语句 2 的频度是 (n-1)*(2n+1)=2n^2-n-1
f(n)=2n^2-n-1+(n-1)=2n^2-2
该程序的时间复杂度 T(n)=O(n^2).
5. 线性阶 O(n)
( 1 )
a=0;
b=1; ①
for (i=2;i<=n;i++) ②
{
s=a+b; ③
b=a; ④
a=s; ⑤
}
解: 语句 1 的频度: 2,
语句 2 的频度: n,
语句 3 的频度: n-1,
语句 4 的频度: n-1,
语句 5 的频度: n-1,
T(n)=2+n+3(n-1)=4n-1=O(n).
6. 线性对数阶 O(log2n )
( 1 )
i=1; ①
while (i<=n)
i=i*2; ②
解: 语句 1 的频度是 1,
设语句 2 的频度是 f(n), 则: 2^f(n)<=n;f(n)<=log2n
取最大值 f(n)= log2n,
T(n)=O(log2n )
O(n^3)
( 2 )
for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
for(k=0;k<j;k++)
x=x+2;
}
}
解:当 i=m, j=k 的时候 , 内层循环的次数为 k 当 i=m 时 , j 可以取 0,1,...,m-1 , 所以这里最内循环共进行了 0+1+...+m-1=(m-1)m/2 次所以 ,i 从 0 取到 n, 则循环共进行了 : 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6 所以时间复杂度为 O(n^3).
我们还应该区分算法的最坏情况的行为和期望行为。如快速排序的最 坏情况运行时间是 O(n^2) ,但期望时间是 O(nlogn) 。通过每次都仔细 地选择基准值,我们有可能把平方情况 ( 即 O(n^2) 情况 ) 的概率减小到几乎等于 0 。在实际中,精心实现的快速排序一般都能以 (O(nlogn) 时间运行。
下面是一些常用的记法:
( 1 )访问数组中的元素是常数时间操作,或说 O(1) 操作。
( 2 )一个算法如 果能在每个步骤去掉一半数据元素,如二分检索,通常它就取 O(logn) 时间。
( 3 )用 strcmp 比较两个具有 n 个字符的串需要 O(n) 时间 。
( 4 )常规的矩阵乘算法是 O(n^3) ,因为算出每个元素都需要将 n 对 元素相乘并加到一起,所有元素的个数是 n^2 。
( 5 )指数时间算法通常来源于需要求出所有可能结果。例如, n 个元 素的集合共有 2n 个子集 , 所以要求出所有子集的算法将是 O(2n) 的 。指数算法一般说来是太复杂了,除非 n 的值非常小,因为,在 这个问题中增加一个元素就导致运行时间加倍。不幸的是,确实有许多问题 ( 如著名 的“巡回售货员问题” ) ,到目前为止找到的算法都是指数的。如果我们真的遇到这种情况, 通常应该用寻找近似最佳结果的算法替代之。
( 6 )有如下复杂度关系经验规则
c < log2N < n < n * Log2N < n^2 < n^3 < 2^n < 3^n < n!
其中 c 是一个常量,如果一个算法的复杂度为 c 、 log2N 、 n 、 n*log2N , 那么这个算法时间效率比较高 ,如果是 2^n , 3^n ,n! ,那么稍微大一些的 n 就会令这个算法不能动了,居于中间的几个则差强人意。