速来报名!AICon北京站鸿蒙专场~ 了解详情
写点什么

递归算法的时间复杂度

  • 2020-02-12
  • 本文字数:12183 字

    阅读完需:约 40 分钟

递归算法的时间复杂度

递归算法大家应该都不陌生吧,其实最开始遇见递归应该是在数学课上,类似于 f(x)=f(x-1)+f(x+1),f(1)=1,f(2)=4,f(3)=3 这种数学题大家应该见过不少,其实思想就是层层递归,最终将目标值用 f(1),f(2),f(3)表示。


之前做个一个需求,需要实现类似操作系统文件夹的功能,我们用 MySQL 数据库记录数据,表字段有 4 列,分别是 id,index_name,pid,is_directory,index_name 记录文件或文件的名字,pid 记录它的父级 id,is_directory 标记它是文件还是文件夹。记录被存下以后,就涉及到取数据的问题了,我们前端需要的目标数据结构是这样的


col 1 | col 2 ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1


                2
3 | `[{``"id"``:1,``"name"``:``"./"``},{``"id"``:2,``"name"``:``"./1.txt"``},`
`{``"id"``:3,``"name"``:``"./dir1/"``},`
`{``"id"``:4,``"name"``:``"./dir1/2.txt"``},...]`
有点类似linux系统的tree命令。 </section> </section> </section></section>
复制代码


第一版代码是这样的:


            </section>        </section>
<section> <section> col 1 | col 2 ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | `tree = []`
`def getTree(pid):`
` ``return`
`for` `index ``in` `childIndexes:`
` ``if` `len(tree) == 0:`
` ``if` `index.is_directory==1 tree.append(`
`{``'id'``:index.``id``,``'name'``:``'./'``+index.index_name+``'/'``}) `
`getTree(index.``id``)`
` ``else``: `
`tree.append(`
`{``'id'``:index.``id``,``'name'``:``'/'``+index.index_name})`
` ``else``: `
` ``for` `item ``in` `tree: `
`if` `item[``'id'``] == index.``id`
` ``if` `item.is_directory==1: tree.append({``'id'``:index.``id``,``'name'``: `
`item[``'name'``]+index.index_name+``'/'``}) `
` ``else``: `
` ``tree.append`
`(`
`{``'id'``:index.``id``,``'name'``:item[``'name'``]+index.index_name`
`}`
`)` </section> </section> </section></section>
复制代码


大概看一下这个算法的时间复杂度,第一层的遍历时间复杂度是 n,第二层遍历的时间复杂度是 n,内层的时间复杂度是 O(n^2),再加上递归,最后的时间复杂度是 O(2^n*n^2),这个算法可见很粗糙,假如递归深度到是 100,最后执行效率简直会让人头皮发麻。接下来我们考虑一下如何优化。


第二版代码:


col 1 | col 2 ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1


                2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | `tree = []`
`def getTree(pid,path=``'./'``):`
` ``return`
` ``for` `index ``in` `childIndexes:`
` ``if` `len(tree) == 0: `
` ``if` `index.is_directory==1 tree.append({``'id'``:index.``id``,`
`'name'``:path+index.index_name+``'/'``}) `
` ``getTree(index.``id``, `
`path+index.index_name+``'/'``)`
` ``else``:`
` ``tree.append({``'id'``:index.``id``,`
`'name'``:path+index.index_name}) `
` ``else``: `
` ``if` `item.is_directory==1: tree.append({``'id'``:index.``id``,`
`'name'``:path+index.index_name+``'/'``})`
` ``else``: `
` ``tree.append({``'id'``:index.``id``,`
`'name'``:path+index.index_name})`

</section> </section>
<section> <section></section> </section> </section></section>
复制代码


我们用变量保存每一次的 path,这次我们看看时间复杂度是多少。第一层遍历时间复杂度是 O(n),加上递归,最后的时间复杂度是 O(2^n*n),不算太理想,最起码比第一次好点。


再看看一个面试的常见的题目,斐波拉契数列,n=1,1,3,5,8,13…,求第 n 位是多少?


一看首先就想到了递归的方式:


            </section>        </section>    </section></section>
复制代码


col 1col 2


1


2


3


4 | def fibSquence(n):


``if n ``in (1,2):


``return


``fibSquence(n-1)+ fibSquence(n-2)


这个算法的时间复杂度是 O(2^n),关于时间复杂度具体看调用次数便能明白。我们考虑一下如何优化,比如求 n=3 是,需要先求 n=2,n=1,但是最开始 n=1,n=2 已经求过,多了两步重复计算。


下面是优化的代码:


            </section>        </section>
<section> <section> col 1 | col 2 ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1
2
3
4
5 | `fibMap = {1:1,2:2}`
`def fibSquence(n):`
` ``else``:`
` ``result = fibSquence(n-1)+ fibSquence(n-2) fibMap.update({n:result})`
` ``return` `result` </section> </section> </section></section>
复制代码


我们用 map 报存中间值,map 是基于 hash 实现的,时间复杂度是 O(1),这样这个算法的时间复杂度就是 O(n)。


但是事实上这个问题大可不必用递归方式求解


            </section>        </section>
<section> <section> col 1 | col 2 ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1
2
3
4
5
6 | `fibMap = {1:1,2:2}`
`def fibSquence(n):`
` ``else``:`
` ``for` `i ``in` `range(3,n+1): `
` ``fibMap.update({i:fibMap[i-1]+fibMap[i-2]})`
` ``return` `fibMap[n]` </section> </section> </section></section>
复制代码


这样我们只用一次遍历,便可以求出目标值。


递归算法的优化大概就是避免重复运算,将中金状态保存起来,以便下次使用,从结构上来看,是将时间复杂度转换为空间复杂度来解决。递归算法的效率其实是非常低的,能不用递归就尽量不用递归;当然了也要具体问题具体对待,比如说开始提到我做的项目遇到的问题,不用递归我还真想不出其他更好的方式解决。


本文转载自宜信技术学院网站。


原文链接:http://college.creditease.cn/detail/189


2020-02-12 15:29757

评论

发布
暂无评论
发现更多内容

GO 进阶学习笔记

zach

微服务 Go 语言

产品经理训练营第二章作业——利益相关者

阿波

智能汽车如何赚钱? (28天写作 Day19/28)

mtfelix

商业模式 28天写作 智能汽车 软件定义汽车

Kubernetes Pod篇:带你轻松玩转Pod

xcbeyond

Kubernetes pod 28天写作 Kubernetes从入门到精通 服务编排

从定义到AST及其遍历方式,一文带你搞懂Antlr4

华为云开发者联盟

Java AST 语言 antlr4 语法分析器

【总结】产品经理训练营 | 02 产品思维和产品意识(上、中)

阿席达卡。

智能building 之智慧城市

张老蔫

28天写作

产品思维和产品意识-利益相关方学习总结

mas

娄底携手浪潮,打造了智慧城市建设的“娄底样板”

【图文并茂,点赞收藏哦!】重学巩固你的Vuejs知识体系

我是哪吒

程序员 面试 Vue 大前端 Web

第二周作业

Geek_6a8931

开发的必杀技:Git 的分支管理

华为云开发者联盟

git Linux 分支

利益相关方分析-公司及团队维度

梁媛

产品经理

数据库覆盖式数据导入方法:部分和完全

华为云开发者联盟

数据库 sql 数据 DWS 覆盖式导入

信任是一种需要牺牲效率持续发出的信号

Justin

心理学 信任 市场营销 28天写作

架构师训练营-大作业:物流系统架构设计

晴空万里

架构师训练营第2期

30+岁、没转管理、加不动班,我的竞争力从哪里来?

博文视点Broadview

我用PHP写的第一个Hello world

熊斌

28天写作

keepalived 实现Nginx高可用安装

庞小辉

【年度重磅】2020华为云社区年度技术精选合集,700页+免费下载!

华为云开发者联盟

数据库 AI 云原生 物联网 华为云

八大案例带你了解图数据库如何洞察数据间关联价值

NebulaGraph

图数据库 图数据库实战

GNUCash 4: 我的使用经验

lidaobing

GNUCash 28天写作

第 2 周作业

老元宵

你以为阿里真的取消周报了?

Ian哥

28天写作

面试官常问的垃圾回收器,这次全搞懂

Silently9527

Java JVM 垃圾回收 GC

Android Styling System

Changing Lin

android

红帽架构师:为什么KubeEdge是2020年我最喜欢的开源项目?

华为云原生团队

开源 云原生 边缘计算 边缘技术

年底想跳槽?先想清楚自己要什么。

一笑

面试 工作 28天写作

计算机网络学习第一课

落曦

屏幕共享功能的应用

anyRTC开发者

android 音视频 WebRTC 在线教育 视频会议

趋势预测:2021年五大流行的编程语言

禅道项目管理

Java php python 爬虫 趋势

递归算法的时间复杂度_文化 & 方法_杨轶_InfoQ精选文章