不会吧不会吧,不会真有人还不会算时间复杂度吧?用十分钟让你明白如何计算时间复杂度

前言:

算法的分析方式有两种:

  1. 事后分析统计方法:编写算法对应程序,统计其执行时间。
    存在问题:编写程序的语言不同,执行程序的环境不同等因素
  2. 事前估算分析方法:撇开上述因素,认为算法的执行时间是问题规模n的函数。

所以我们引入了时间复杂度的概念来对算法进行分析

分析算法的执行时间

求出算法所有原操作的执行次数(也称为频度),它是问题规模n的函数,用 T(n) 表示。

算法执行大致时间 = 原操作所需的时间 * T(n)
所以算法的执行时间与 T(n) 成正比
为此用 T(n) 表示算法的执行时间

频度的计算

先来看一段代码

for (i = 0; i < n; i++) {                                      //语句 1   频度为 n+1
        for (j = 0; j < n; j++) {                              //语句 2   频度为 n*(n+1)
                c[i][j] = 0;                                   //语句 3   频度为 n*n 
                for (k = 0; k < n; k++)                        //语句 4   频度为 n*n*(n+1) 
                        c[i][j] = c[i][j] + a[i][k] * b[k][j]; //语句 5   频度为 n*n*n       
        }
}

来解释一下,每个语句的频度

语句1:

不看内循环,单独看语句 1 ,当i范围在 [0,n-1] 时,它执行了n次,i=n时还执行了一次(判断后跳出循环),所以是n+1次。

语句2:

一样,不看 内循环 和 外循环,单独看语句2,语句2执行了n+1次 ,再看外循环,也就是语句1 循环了 n 次(频度是n+1,但是 循环次数并不是n+1次) 所以语句2 的频度为 n*(n+1)

语句3:

不看外循环,执行一次,再看外循环,执行n*n次 故 频度为n²

语句4和语句5的频度就不做解释了

得出这个段代码的 频数之和

T(n) = 2n³ + 3n² + 2n + 1

算法的执行时间用时间复杂度来表示

T(n) = O(f(n))
记号“O”读作“大O”,它表示随问题规模n的增大算法执行时
间的增长率和f(n)的增长率相同。

T(n)= O(f(n))表示存在一个正的常数M,使得当n≥n0时都满足:
| T(n) | ≤ M | f(n) |
f(n)是 T(n)的上界
这种上界可能很多,通常取最接近的上界,即紧凑上界
大致情况:lim n->∞ T(n) / f(n) = M

是不是觉得很啰嗦,怎么涉及到这种概念 ,没事 看不懂也没事,其实,只要求出T(n) 的最高阶就行了 忽略其他低阶项和常系数
例如
T(n) = 2n³ + 3n² + 2n + 1 = O(n³)
T(n) =2n² + 2n + 1 = O(n²)
T(n) = n + 1 = O(n)
T(n) = 1 = O(1)
一个没有循环的算法的执行时间与问题规模n无关,记作0(1),也称作常数阶。
一个只有一重循环的算法的执行时间与问题规模n的增长呈线性增大关系,记作O(n),也称线性阶。
其余常用的算法时间复杂度还有平方阶O(n²)、 立方阶O(n³)、 对数阶O(log2n)、指数阶O(2^n)等。

对数阶的例子:

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

执行次数为x次
2^x = n
则 x = log 2 n
时间复杂度为O(log2n)

指数阶的例子

int aFunc(int n) {
        if (n <= 1) 
            return 1;
        else 
        	return aFunc(n - 1) + aFunc(n - 2);
}

显然运行次数,T(0) = T(1) = 1,同时 T(n) = T(n - 1) + T(n - 2) + 1,这里的 1 是其中的加法算一次执行。显然 T(n) = T(n - 1) + T(n - 2) 是一个斐波那契数列,通过归纳证明法可以证明,当 n >= 1 时 T(n) < (5/3)^n,同时当 n > 4 时 T(n) >= (3/2)^n。所以该方法的时间复杂度可以表示为 O((5/3)^n),简化后为 O(2^n)。

补充

T(n)的简便计算

算法中的基本操作一般是最深层循环内的原操作。
算法执行时间大致 = 基本操作所需的时间 X 其运算次数。
在算法分析时,计算T(n)时仅仅考虑基本操作的运算次数。
例如上述的例子:

for (i = 0; i < n; i++) {                                     
        for (j = 0; j < n; j++) {                              
                c[i][j] = 0;                                   
                for (k = 0; k < n; k++)                        
                        c[i][j] = c[i][j] + a[i][k] * b[k][j];     
        }
}

基本语句是 c[i][j] = c[i][j] + a[i][k] * b[k]
在这里插入图片描述
这种简化的时间复杂度分析方法得到的结果相同,但
分析过程更简单。

常用的时间复杂度所耗费的时间从小到大依次是

O(1 )< O(logn) < O(n) < O(n*logn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

因为初学数据结构和算法,可能有不严谨的地方或者错误欢迎指出

  • 40
    点赞
  • 82
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值