谁能给我讲讲关于递归的东西。。好难理解啊。。

Question

/**
 * Created by LR on 2016/12/7.
 */
function permutate(str) {
    var result = [];
    if(str.length == 1){
        return [str]
    }else {
        var preResult = permutate(str.slice(1))
        for (var j = 0; j < preResult.length; j++) {
            console.log(preResult[j])
            for (var k = 0; k < preResult[j].length+1; k++) {

                var temp=preResult[j].slice(0,k)+str[0]+preResult[j].slice(k);
                result.push(temp);
            }
        }
        console.log("!")
        console.log(result)
        return result
    }

}

permutate('abc');

第一次是abc 进入函数，然后长度大于1进入else；
所以这里就应该是
var preResult = permutate("bc")
之后呢？？我就想到bc进入函数，长度大于一
之后就 var preResult = permutate("c")
长度等于1了 然后就返回一个c 这个for循环是怎么执行的？？ 谁能告诉我一下。。。
这个是全排列的算法

Answer 1

就是自己调用自己，根据条件结束调用，然后达成目的一种算法。

Answer 2

个人经验哈，写递归函数，控制好两点。arguments，每次调用参数发生变化。return，控制函数的结束以及值得返还

Answer 3

function fun(num){

if(num<=1){
    return 1;
}else{
    return fun(num-1)+num;
}

}
fun(3);//6
//这是一个累加
递归实质上就是将一个大问题分解为若干个小问题(这个过程就是递)，然后根据已知的答案求未知的
首先，我们不知道fun（3）等于多少,但是我知道最后的结果等于fun（num-1）+3，
然后我们再将他进一步分解.....当num为1的时候(fun(1-1)+1<=1 )，我们有了已知的答案1,
则再回头(就是归的过程)fun(1-1)+1就是fun(1)分解的结果，函数执行的过程就是再将他带回去计算
题主理解了这个可以再选择看看汉诺塔，然后看看快速排序之类的，都会用到递归，多练练就能掌握了
PS:(装完逼就逃 -_->)

Answer 4

递归真的很烦，光看代码需要你左右脑都动用起来，建议画流程图，能有效的节省你的思考时间，同时还能理清思路

Answer 5

理解递归还是用函数式编程好，关键两步写出递归函数，处理递归基

Answer 6

递归的思想类似于逆向的数学归纳法，要解决规模为n的问题，先将其处理一下，化归到规模为n-1的问题。一直化归下去，变为规模为1的问题。然后解决这个规模为1的问题。

推广的讲，将一个问题朝一个固定方向化归为同类问题，持续下去，直到这个问题可以容易做解。当k可做解，则k+1可做解，则原问题可做解。

虽然很多时候我们简单说为，调用自身就是递归，但是需要了解其这样做的动机：递归的方向以及解决（终止）的时机。

Answer 7

建议楼主先从最简单的两位字符递归开始分析，比如 permutate('ab');
它发生了什么呢，如下:

1.进入permutate函数内部，此时result为[]，由于'ab'的长度不是1，所以走到了else分支
2.取得的值 preResult = 'b'(这里递归了一次，取了后面的一位字符)
3.进入for循环，此时只将‘b’进行循环
4.进入关键的k(for)循环，循环了2次(注意，前面是一个字符串进入循环，所以k循环的次数是str.length+1)
5.k循环中

• k为0,生成一个tmp值'ab'('b'.slice(0,0)为空,str[0]为'a',‘b’.slice(0)为b)
  并且将那个'ab'push进result中

• k为1,生成一个tmp值‘ba’('b'.slice(0,1)为'b',str[0]为'a',‘b’.slice(1)为空)
  并且将那个'ba'push进result中

1. return result,所以这时最终的结果为['ab','ba']

同理,当三位字符递归时， permutate('abc');

1.进入permutate函数内部，此时result为[]，由于'abc'的长度不是1，所以走到了else分支
2.取得的值 preResult = ['bc','cb'] (就是上面一步中两位字符递归后的结果,只不过是将ab换为了bc)
3,进入for循环，此时for循环2次(分别为'bc'和'cb')

• ‘bc’循环时，进入关键的k循环，k循环的次数为3

  • k=0,tmp值为‘abc’

  • k=1,tmp值为'bac'

  • k=2,tmp值为'bca'

  • 循环结束后,result为['abc','bac','bca']

• ‘cb’循环时，进入关键的k循环，k循环的次数同样为3

  • k=0,tmp值为‘acb’

  • k=1,tmp值为'cab'

  • k=2,tmp值为'cba'

  • 循环结束后,result为['abc','bac','bca','acb','cab','cba']

4.返回最终的result，运行程序，发现结果完全匹配。分析结束。

接下来如果四位字符递归同理，路得一步一步走，莫急！

PS; ~码字不容易啊~

Answer 8

用递归实现阶乘的算法，这个比较简单，理解了这个再去理解复杂的，原理都是一样的。

function factorial (num) {
    if (num == 1) {
        return 1;
    } else {
        return num * factorial(num - 1);
    }
}

factorial(2) // 2         2 * 1
factorial(5) // 120       5 * 4 * 3 * 2 * 1

Answer 9

很好理解，递归就是你惹女朋友生气了，她说你把自己扇到脸红为止。

自己扇自己的过程就是递归调用，停止条件是脸红了。

Answer 10

最简单的理解，就是自己调用自己，然后到末端就全部停止了。

Answer 11

想要理解递归，首先你要理解递归。