??斗地主捕鱼电竞提现秒到 广告位招租 - 15元/月全站展示
??支付宝搜索579087183领大额红包 ??伍彩集团官网直营彩票
??好待遇→招代理 ??伍彩集团官网直营彩票
??络茄网 广告位招租 - 15元/月全站展示
JavaScript中的递归

转载   Fundebug   2018-11-15   浏览量:15


译者按: 程序员应该知道递归,但是你真的知道是怎么回事么?

递归简介

一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。

我们来举个例子,我们可以用4的阶乘乘以4来定义5的阶乘,3的阶乘乘以4来定义4的阶乘,以此类推。

factorial(5) = factorial(4) * 5
factorial(5) = factorial(3) * 4 * 5
factorial(5) = factorial(2) * 3 * 4 * 5
factorial(5) = factorial(1) * 2 * 3 * 4 * 5
factorial(5) = factorial(0) * 1 * 2 * 3 * 4 * 5
factorial(5) = 1 * 1 * 2 * 3 * 4 * 5

用Haskell的Pattern matching 可以很直观的定义factorial函数:

factorial n = factorial (n-1)  * n
factorial 0 = 1

在递归的例子中,从第一个调用factorial(5)开始,一直递归调用factorial函数自身直到参数的值为0。下面是一个形象的图例:
JavaScript中的递归

递归的调用栈

为了理解调用栈,我们回到factorial函数的例子。

function factorial(n) {
    if (n === 0) {
        return 1
    }

    return n * factorial(n - 1)
}

如果我们传入参数3,将会递归调用factorial(2)、factorial(1)factorial(0),因此会额外再调用factorial三次。

每次函数调用都会压入调用栈,整个调用栈如下:

factorial(0) // 0的阶乘为1 
factorial(1) // 该调用依赖factorial(0)
factorial(2) // 该调用依赖factorial(1)
factorial(3) // 该掉用依赖factorial(2)

现在我们修改代码,插入console.trace()来查看每一次当前的调用栈的状态:

function factorial(n) {
    console.trace()
    if (n === 0) {
        return 1
    }

    return n * factorial(n - 1)
}

factorial(3)

接下来我们看看调用栈是怎样的。
第一个:

Trace
    at factorial (repl:2:9)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)
    at REPLServer.onLine (repl.js:513:10)
    at emitOne (events.js:101:20)

你会发现,该调用栈包含一个对factorial函数的调用,这里是factorial(3)。接下来就更加有趣了,我们来看第二次打印出来的调用栈:

Trace
    at factorial (repl:2:9)
    at factorial (repl:7:12)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)
    at REPLServer.onLine (repl.js:513:10)

现在我们有两个对factorial函数的调用。

第三次:

Trace
    at factorial (repl:2:9)
    at factorial (repl:7:12)
    at factorial (repl:7:12)
    at repl:1:1
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)

第四次:

Trace
    at factorial (repl:2:9)
    at factorial (repl:7:12)
    at factorial (repl:7:12)
    at factorial (repl:7:12)
    at repl:1:1
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)

设想,如果传入的参数值特别大,那么这个调用栈将会非常之大,最终可能超出调用栈的缓存大小而崩溃导致程序执行失败。那么如何解决这个问题呢?使用尾递归。

尾递归

尾递归是一种递归的写法,可以避免不断的将函数压栈最终导致堆栈溢出。通过设置一个累加参数,并且每一次都将当前的值累加上去,然后递归调用。

我们来看如何改写之前定义factorial函数为尾递归:

function factorial(n, total = 1) {
    if (n === 0) {
        return total
    }

    return factorial(n - 1, n * total)
}

factorial(3)的执行步骤如下:

factorial(3, 1) 
factorial(2, 3) 
factorial(1, 6) 
factorial(0, 6) 

调用栈不再需要多次对factorial进行压栈处理,因为每一个递归调用都不在依赖于上一个递归调用的值。因此,空间的复杂度为o(1)而不是0(n)。

接下来,通过console.trace()函数将调用栈打印出来。

function factorial(n, total = 1) {
    console.trace()
    if (n === 0) {
        return total
    }

    return factorial(n - 1, n * total)
}

factorial(3)

很惊讶的发现,依然有很多压栈!

// ...
// 下面是最后两次对factorial的调用
Trace
    at factorial (repl:2:9) // 3次压栈
    at factorial (repl:7:8)
    at factorial (repl:7:8)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)
Trace
    at factorial (repl:2:9) // 最后第一调用再次压栈
    at factorial (repl:7:8)
    at factorial (repl:7:8)
    at factorial (repl:7:8)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)

这是为什么呢?
在Nodejs下面,我们可以通过开启strict mode, 并且使用--harmony_tailcalls来开启尾递归(proper tail call)。

'use strict'

function factorial(n, total = 1) {
    console.trace()
    if (n === 0) {
        return total
    }

    return factorial(n - 1, n * total)
}

factorial(3)

使用如下命令:

node --harmony_tailcalls factorial.js

调用栈信息如下:

Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)

你会发现,不会在每次调用的时候压栈,只有一个factorial。

注意:尾递归不一定会将你的代码执行速度提高;相反,可能会变慢。不过,尾递归可以让你使用更少的内存,使你的递归函数更加安全 (前提是你要开启harmony模式)。

那么,博主这里就疑问了:为什么尾递归一定要开启harmony模式才可以呢?

关于Fundebug

Fundebug专注于JavaScript、微信小程序、微信小游戏、支付宝小程序、React Native、Node.js和Java实时BUG监控。 自从2016年双十一正式上线,Fundebug累计处理了7亿+错误事件,得到了Google、360、金山软件、百姓网等众多知名用户的认可?;队夥咽杂?!

JavaScript中的递归

版权声明

转载时请注明作者Fundebug以及本文地址:
https://blog.fundebug.com/2017/06/14/all-about-recursions/

转载自://blog.51cto.com/13957060/2317401

招聘 不方便扫码就复制添加关注:程序员招聘谷,微信号:jobs1024



用JS实现的俄罗斯方块
javascript写的俄罗斯方块的小游戏。游戏界面就是一个html的tab表格。方块的表示就是给表格对应的格子加上背景色。
JQuery判断radio属性为空的时候错误提示信息显示位置不正确解决办法
只需要定义一个以下标签即可以想让错误信息显示到哪里就显示到哪里&lt;label&nbsp;for=&quot;name&quot;&nbsp;class=&quot;error&quot;&gt;&lt;/label&gt;说明:标签名必须为labelfor属性的值与对应input的name属性一致,通过这里与input关联,所以想哪里显示就哪里显示class属性必须为errorlab
javascript常用时间函数集合
代码:/*@desc:时间日期函数集合@author[Lee]<[<[email protected]>]>*/functiondatetime(){/*@desc:内部方法,不足10补[email protected]传入数值@returnret转换后的数值*/this.parsetime=function(input){varretif(input>=0&&in
javascript删除数组/对象中的元素
一、数组:代码:/*@desc:删除数组中的元素@paramarr原数组@paramitem数组索引,只能是数字索引@paramlen要删除的长度@returnarr删除元素后的数组*/functionunset(arr,item,len=1){arr.splice(item,len)returnarr}测试:vararr=newArray(1,2,3,4)varret=unset(arr,1,2
javascript数组排序函数
代码:/*@desc:表格排序类@paramdata待排序数组*/functiontablesort(data){this.data=datathis.sortby=true/*@desc:主方法,排序@paramitem排序字段@returnret排序后的数据*/this.sort=function(item){if(this.sortby){varret=this.data.sort(func
javascript时间缀转时间字符串
代码:/*@desc:时间缀转时间字符串@paramtime时间缀,长度为[email protected]时间字符串格式为:2018-06-1022:00:00*/functiontimetostr(time){this.time=time/*@desc:内部方法,若数字小于10补[email protected]传入数值@returnret格式化后的数值*/this.parsetime=function(input){
用JS实现的贪吃蛇游戏
运用前端javascript的知识,做了一个简单的贪吃蛇的小游戏。从头到尾一步一步的思路和代码。最后有完整版的代码。不过功能还不够完善,只有个大概的能玩的东西,有兴趣的话还能在优化改进。
javascript字符串与json互转
代码:/*@desc:字符串转json函数@author<lee>[<[email protected]>]@paramstr字符串@returnjsonjson对象*/functionstrtojson(str){vararr=str.split('&')varjson={}for(variinarr){vark=arr[i].split('=')[0]varv=ar
数组排序,不满三位数值的按照原来的位数进行比较,超过三位的取后面三位进行比较
第一步:首先要判断数值的长度,先把他转成字符串,在判断位数,截取后面的三位进行比较vararr=[12432,34,535,89002,452,50]for(vari=0;i<arr.length;i++){arr[i]=arr[i].toString()if(arr[i].length>3){arr[i]=arr[i].substr(arr[i].length-3)}}第二步:再把字
JavaScript file上传类型
不同文件类型的配置(accept)