javascript 递归
概念
在程序中函数直接或间接调用自己，然后跳出结构，返回结果
递归的步骤(技巧)
- 假设递归函数已经写好
- 寻找递推关系
- 将递推关系的结构转换为递归体
- 将临界条件加入到递归体中
示例
求1+2+3+3+...n的和。
二逼青年：
首数加位数 ，乘以个数除以2
function sum(n){
return (1 + n) * n / 2
}
console.log(sum(100)) //5050
普通青年：
写个循环
function sum(n) {
let result = n
while (n-- > 0) {
result += n
}
return result
}
console.log(sum(100)) //5050
文艺青年：
有规律的序数运算，所以用递归
/***
* 假设递归函数已经写好为sum,既sum(100),就是求1-100的和
* 寻找递推关系: 就是 n 与 n-1 ,或 n-2 之间的关系，sum(n) == sum(n-1) + n, 前面的数字（n-1）之和和sun(n-1)加上本身n
*/
function sum(n){
return n==1 ? 1 : sum(n-1) + n //n=1的时候跳出
}
console.log(sum(100)) //5050
求1+3+5+7+9+...(2n-1)第n项的结果和前n项和
二逼青年：
用公式值为n的平方
function sum(n){
return n * n
}
console.log(sum(5)) //25 =1+3+5+7+9
普通青年：
写个循环
function sum(n) {
let result = 0
while (2 * n - 1 >= 1) {
result += 2 * n - 1
n -= 1
}
return result
}
console.log(sum(5)) //25
文艺青年：
有规律的序数运算，所以用递归
/***
* 假设递归函数已经写好为sum,既sum(100),就是求1-（2n-1）的和
* 寻找递推关系: 就是 n 与 2n-1 之间的关系，sum(n) == sum(n-1) + (2n-1)
*/
function sum(n) {
return n == 1 ? 1 : sum(n - 1) + (2 * n - 1) //n=1的时候跳出
}
console.log(sum(5)) //25
求2+4+6+8+10+...2n第n项的结果和前n项和
二逼青年：
用公式值为n(n+1)
function sum(n){
return n * (n + 1)
}
console.log(sum(5)) //30 =2+4+6+8+10
普通青年：
写个循环
function sum(n) {
let result = 0
while (2 * n > 0) {
result += 2 * n
n -= 1
}
return result
}
console.log(sum(5)) //30
文艺青年：
有规律的序数运算，所以用递归
/***
* 假设递归函数已经写好为sum,既sum(100),就是求1- 2n的和
* 寻找递推关系: 就是 n 与 2n 之间的关系，sum(n) == sum(n-1) + 2n
*/
function sum(n) {
return n == 0 ? 0 : sum(n - 1) + 2 * n //n=0的时候跳出
}
console.log(sum(5)) //30
斐波拉契(Fibonacci)运算(兔子生兔子的故事)
一对兔子从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少
产量分析：1， 1， 2， 3， 5， 8， 13， 21 ....n
第n个月的兔子总数 = 第n-1个月的兔子总数 + 第n-2个月的兔子总数
问题： 求任意月兔子的总数
二逼青年：
没公式，不会算，读书少，别骗我
普通青年：
循环大法好
var sum = function (n) {
var a1 = 1, a2 = 1, a3 = 0;
if (n <= 2) {
return 1;
}
for (var i = 0; i < n - 1; i++) {
a3 = a1 + a2;
a1 = a2;
a2 = a3;
}
return a3;
}
console.log(sum(5)); //8
文艺青年：看我的递归大法吧
有规律的序数运算，所以用递归
/***
* 假设递归函数已经写好为sum,既sum(10),就是第10个月兔子的总数
* 寻找递推关系: 倒数第3个数 = 倒数第二个数(n-1) + 倒数第一个数(n-2)
*/
function sum(n) {
return (n <= 2) ? 1 : sum(n-1) + sum(n-2) //n<=1的时候跳出
}
console.log(sum(5)) //8
mul函数
实现一个函数mul，运算结果可以满足如下结果
1.mul(2)(3).valueOf() //6
2.mul(3)(4)(5)(6).valueOf() //360
二逼青年 & 普通青年
实现 mul(2)(3).valueOf() =>6
function mul(a) {
return function (b) {
let obj = {}
obj.valueOf = function () {
return a * b
}
return obj
}
}
console.log(mul(2)(3).valueOf()) //6
实现 mul(3)(4)(5)(6).valueOf() =>360
function mul(a) {
return function (b) {
return function (c) {
return function (d) {
let obj = {}
obj.valueOf = function () {
return a * b * c * d
}
return obj
}
}
}
}
console.log(mul(3)(4)(5)(6).valueOf()) //360
文艺青年：看你俩写的太JB累了。假如有无限级回调呢，比如mul(3)(4)(5)(6)....(n).valueOf(), n等于100，你不累死啊。
二逼青年 & 普通青年：你就扯吧，有这样的需求吗？
文艺青年：呵呵，没有这样的需求，那就不抬杠了哈，用递归吧，更简单
function mul(x) {
const result = (y) => mul(x * y);
result.valueOf = () => x;
return result;
}
console.log(mul(2)(3).valueOf()) //6
console.log(mul(3)(4)(5)(6).valueOf()) //360
可以看到，递归写法简单优美，省去考虑很多边界条件的时间。当然，递归算法会保存很多的临时数据，类似于堆栈的过程，如果栈深太深，就会造成内存用尽，程序崩溃的现象。Java为每个线程分配了栈大小，如果栈大小溢出，就会报错，这时候还是选择递推好一点。
上面的例子都是些简单的例子，还需许多例子比如 汉诺塔，细胞分裂，爬楼梯等经典例子。我读书少，没做更深的钻研...
关于递归中的的arguments.callee
callee 是 arguments 对象的一个属性。它可以用于引用该函数的函数体内当前正在执行的函数。这在函数的名称是未知时很有用，例如在没有名称的函数表达式 (也称为“匿名函数”)内。
早期版本的 JavaScript不允许使用命名函数表达式，出于这样的原因, 你不能创建一个递归函数表达式
function factorial (n) {
return !(n > 1) ? 1 : factorial(n - 1) * n;
}
[1,2,3,4,5].map(factorial);
但是
[1,2,3,4,5].map(function (n) {
return !(n > 1) ? 1 : /* what goes here? */ (n - 1) * n;
});
这个不行。为了解决这个问题， arguments.callee 添加进来了。然后你可以这么做
[1,2,3,4,5].map(function (n) {
return !(n > 1) ? 1 : arguments.callee(n - 1) * n;
});
然而，这实际上是一个非常糟糕的解决方案，因为这 (以及其它的 arguments, callee, 和 caller 问题) 使得在通常的情况（你可以通过调试一些个别例子去实现它，但即使最好的代码是最理想的，你也没必要去检查调试它）不可能实现内联和尾递归。另外一个主要原因是递归调用会获取到一个不同的 this 值，例如：
var global = this;
var sillyFunction = function (recursed) {
if (!recursed) { return arguments.callee(true); }
if (this !== global) { //this居然不等于global
console.log("This is: " + this);
} else {
alconsole.logert("This is the global");
}
}
sillyFunction();
再例如这道题目：计算12345*....n 的结果，就是阶乘函数
function factorial(num){
if (num <=1) {
return 1;
} else {
return num * factorial(num-1)
}
}
定义阶乘函数一般都要用到递归算法；如上面的代码所示，在函数有名字，而且名字以后也不会变的情况下，这样定义没有问题。
但问题是这个函数的执行与函数名 factorial 紧紧耦合在了一起。为了消除这种紧密耦合的现象，可以像下面这样使用 arguments.callee
function factorial(num){
if (num <=1) {
return 1;
} else {
return num * arguments.callee(num-1);
}
}
在这个重写后的 factorial()函数的函数体内，没有再引用函数名 factorial。这样，无论引用函数时使用的是什么名字，都可以保证正常完成递归调用, 如下代码：
function factorial(num) {
if (num <= 1) {
return 1;
} else {
return num * arguments.callee(num - 1);
}
}
var test = factorial;
console.log(test(5)); //120
factorial = function () {
return 0;
}
console.log(test(5));// 120 如果没有使用arguments.callee，将返回0,因为factorial 在外部被重新定义了
在此，变量 trueFactorial 获得了 factorial 的值，实际上是在另一个位置上保存了一个函数的指针。然后，我们又将一个简单地返回 0的函数赋值给 factorial 变量。如果像原来的 factorial() 那样不使用 arguments.callee，调用 trueFactorial()就会返回 0。可是，在解除了函数体内的代码与函数名的耦合状态之后，trueFactorial()仍然能够正常地计算阶乘；至于factorial()，它现在只是一个返回 0的函数。
现在已经不推荐使用arguments.callee()；
原因：访问 arguments 是个很昂贵的操作，因为它是个很大的对象，每次递归调用时都需要重新创建。影响现代浏览器的性能，还会影响闭包。
那不能用咋办呢？记得有到面试题是这样的，接受参数 n=5，不用for循环输出数组【1,2,3,4,5】
这是用递归的思路，配合arguments.callee，代码如下
function print(n) {
var arr = []
return (function () {
arr.unshift(n)
n--
if (n > 0) {
arguments.callee()
}
return arr
})()
}
print(5) // [1,2,3,4,5]
用setTimeout 实现setInterval
function say(){
//something
setTimeout(say,200);
}
setTimeout(say,200)
// or
function say(){
//something
setTimeout(arguments.callee,200);
}
setTimeout(say,200)
没有替代方案的 arguments.callee
下面的例子是没有可以替代 arguments.callee 的方案的，因此弃用它时会产生一个BUG (参看 bug 725398):
function createPerson (sIdentity) {
var oPerson = new Function("alert(arguments.callee.identity);");
oPerson.identity = sIdentity;
return oPerson;
}
var john = createPerson("John Smith");
john();
利用命名函数表达式也可以实现上述例子的同样效果
function createPerson (identity) {
function Person() {
console.log(Person.identity);
}
Person.identity = identity;
return Person;
}
var john = createPerson("John Smith");
john(); //John Smith
[完]
