数据结构 - 时间复杂度与空间复杂度

CLAN-Brave

已于 2022-07-05 15:37:22 修改

阅读量1.1k

点赞数

分类专栏：数据结构文章标签：数据结构算法

于 2022-04-30 18:51:21 首次发布

本文链接：https://blog.csdn.net/weixin_51626258/article/details/124515716

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、时间复杂度

1. 时间复杂度的概念

执行算法所需的计算工作量。一般来说，计算机算法是问题规模n的函数f(n),算法的时间复杂度也因此记做T(n)=O(f(n))

计算时间复杂度的规则：

用常数1取代运行次数函数中的所有加法常数
在修改后的函数中，只保留最高阶项
如果最高阶项存在且不是1，则去除这个项相乘的常数

举个栗子🔊
int sum=0;                 -执行一次
sum+=1;                    -执行一次
System.out.println(sum);   -执行一次

这个算法的运行次数函数是f(n)=3。根据规则: 第一步把常数项3改为1 -> 在保留最高阶项时发现，它没有最高阶。所以最终时间复杂度为O(1)，也就是常数阶
① 规则的原理

观察下图，当f(n)中的n不断增大时，常数项以及其他次要项对f(n)的影响几乎可以忽略不计

② 常见的时间复杂度

运行次数函数（举例）时间复杂度
6n+5 O(n) - 线性阶
6n^2+6n+6 O(n^2) - 平方阶
5lg $\displaystyle$ N+20 O(lgN) - 对数阶
2n+3n*lgN+6 O(n*lgN) - nlgN阶
6n^3+2n^2+n+6 O(n^3) - 立方阶
2^n O(2^n) - 指数阶
③ 常见的时间复杂度的耗时曲线

运行次数函数（举例）	时间复杂度
6n+5	O(n) - 线性阶
6n^2+6n+6	O(n^2) - 平方阶
5lg $\displaystyle$ N+20	O(lgN) - 对数阶
2n+3n*lgN+6	O(n*lgN) - nlgN阶
6n^3+2n^2+n+6	O(n^3) - 立方阶
2^n	O(2^n) - 指数阶

2. 代码中时间复杂度的计算

2 计算fun2的时间复杂度

分析：整个代码执行次数为1+2*N+1+10，函数表达式f(n)=2*N+13。根据规则：略去尾数13 和系数2后，没有最高阶。最终得到时间复杂度为O(N)，关键的代码其实就是for循环

答案：O(N)

2 计算func3的时间复杂度

分析：第一个循环进行O(M)次，第二个循环进行O(N)次，两次循环共同完成该函数操作。代码执行次数为1+M+N+1次，函数表达式f(n)=M+N+2。根据规则略去常数项...

答案：O(M+N)

🧐：计算时间复杂度最关键的就是循环部分，接下来我们关注循环吧~

2 下面是一个循环嵌套代码，计算这段代码的时间复杂度

分析：内循环第一题已经分析出是O(n)，而外循环就是将内循环这个时间复杂度为O(n)的语句再循环n次。总共循环次数也就是n个n相加求和，n+n+n+...+n=[(n+n)*n]/2=n^2

所以这段代码的时间复杂度就是O(n^2)

答案：O(n^2)

2 将上一题外循环的循环次数改成m，计算该段循环嵌套代码的时间复杂度

分析：内循环是O(n)，外循环就是将内循环这个时间复杂度为O(n)的语句再循环m次。所以同理计算出这段代码的时间复杂度就是O(M*N)

答案：O(m*n)

🧐：经过总结得出，循环的时间复杂度等于该循环体的时间复杂度乘以该循环运行的次数

2 那下面这个循环嵌套体的时间复杂度是多少

分析：内循环j=i，受外部循环控制

当i=0时，内循环执行了n-1次，

当i=1时，内循环执行了n-2次，

... ...

当i=n-1时，内循环执行了1次

总的循环次数为：(n-1)+(n-2)+...+1=n*(n+1)/2=(n^2)/2+n/2

根据规则，得出最后的时间复杂度为O(n^2）

答案：O(n^2)

🧐：经过观察发现，即使内循环受外循环控制，执行次数不断变化且没有n次，但是这些变动的数值比较小，仍然可以忽略不计

2 计算下列代码的时间复杂度

分析：由于每次count乘以2之后，就距离n更近了一分。也就是说，有多少个2相乘后大于 n，就会退出循环。由2^x=n得到x=lgN，所以这个循环的时间复杂度就是O(lgN)

答案：O(lgN)

计算下列代码的时间复杂度

分析：function函数的时间复杂度是O(1)。for循环调用时间复杂度为O(1)的函数，其实相当于for循环调用一个时间复杂度为O(1)的循环。分析方式和循环嵌套是一致的

答案：O(1)

假设function是这样的，计算下列代码的时间复杂度

分析：function函数的时间复杂度是O(n)。for循环调用时间复杂度为O(n)的函数，其实相当于for循环调用一个时间复杂度为O(n)的循环。时间复杂度为O(n^2)

答案：O(n^2)

🧐：经过观察发现，分析函数的调用的时间复杂度和循环嵌套是一致的

计算冒泡排序(bubbleSort)的时间复杂度

分析：根据上面的总结，结合冒泡排序的思想。可以直接得出时间复杂度为O(n^2)

该段冒泡代码中总共有n个数字参与循环排序，所以第一个for循环表示有n轮循环；

每一轮当中每个数字参与比较，有n个数字，所以第二个for循环表示的是n个数字；

经过计算得出的时间复杂度就是O(n^2)

答案：O(n^2)

计算二分查找(binarySearch)的时间复杂度

分析：最坏情况是，找到最后只剩一个数字即begin==end的时候。二分查找，每找一次，循环次数n减一半成n/2。所以问题就转化为：每查找一次循环次数减少1/2，运行多少次后，n最终降为1。列出数学表达式：(1/2)*x=1 -> x=logN（通常忽略下角标2）

答案：O(logN)

计算递归函数的时间复杂度

分析：递归数列时间复杂度公式：递归的次数a*每次递归后代码段执行的次数b。这里的b始终是1，只需求出a即递归了几次就行。n -> n-1 -> n-1-1 -> ... ->1，从1~n递归n次

答案：O(N)

计算斐波那契递归fibonacci的时间复杂度

分析：画图，斐波那契数列的递归次数如下图

递归的次数a=n

每次递归后代码段执行的次数b=2^n-1（等比数列求和）

总的执行次数=a*b，时间复杂度=总的执行次数函数->规则=O(2^n)

答案：O(2^n)

🧐：对代码使用规则，比计算出整段代码的执行次数函数后，对执行次数函数使用规则更快

计算代码的时间复杂度时，对于复杂的代码要先学会从中看到简单的组成部分：

无非就是单句代码段+各种循环+循环的并列出现+嵌套出现+函数调用组成

再从单个组成部分看到本质：

冒泡排序 -> 两个for循环的循环嵌套；二分查找 -> for循环的对数阶 ...

看看下面这段复杂的代码，如何快速的计算出时间复杂度

图中标注了每段代码的执行次数，实际上我们不这么做。我们直接关注for循环和函数调用：

函数调用的时间复杂度是O(n)；

第一个for循环->外循环时间复杂度为O(n)，内循环时间复杂度是O(n).最终复杂度为O(n^2)；

第二个for循环->忽略细微改变，就是两个for循环嵌套，时间复杂度都是O(n)，最终为O(n^2)

n与n^2，随着n不断增大，n对n^2产生的影响微乎极微，所以最终时间复杂度为O(n^2)