递归思想

递归指的是一个过程：函数不断引用自身，直到引用的对象已知。递归就是在函数内部调用自己的函数被称之为递归。
周末你带着女朋友去电影院看电影，女朋友问你，咱们现在坐在第几排啊？电影院里面太黑了，看不清，没法数，现在你怎么办？
递归思想：你就问前面一排的人他是第几排，你想只要在他的数字上加一，就知道自己在哪一排了。但是，前面的人也看不清啊，所以他也问他前面的人。就这样一排一排往前问，直到问到第一排的人，说我在第一排，然后再这样一排一排再把数字传回来。直到你前面的人告诉你他在哪一排，于是你就知道答案了。
这就是一个非常标准的递归求解问题的分解过程，去的过程叫“递”，回来的过程叫“归”。基本上，所有的递归问题都可以用递推公式来表示。
刚刚这个例子，我们用递推公式将它表示出来就是这样的：
f(n) = f(n-1) + 1其中，f(1) = 1
f(n) 表示你想知道自己在哪一排，f(n-1) 表示前面一排所在的排数，f(1)=1 表示第一排的人知道自己在第一排。

递归的三个条件

刚刚这个例子是非常典型的递归，那究竟什么样的问题可以用递归来解决呢？我总结了三个条件，只要同时满足以下三个条件，就可以用递归来解决。

• 一个问题的解可以分解为几个子问题的解
  何为子问题？子问题就是数据规模更小的问题。比如，前面讲的电影院的例子，你要知道，“自己在哪一排”的问题，可以分解为“前一排的人在哪一排”这样一个子问题。
• 这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样
  比如电影院那个例子，你求解“自己在哪一排”的思路，和前面一排人求解“自己在哪一排”的思路，是一模一样的。
• 存在递归终止条件
  把问题分解为子问题，把子问题再分解为子子问题，一层一层分解下去，不能存在无限循环，这就需要有终止条件。
  还是电影院的例子，第一排的人不需要再继续询问任何人，就知道自己在哪一排，也就是 f(1)=1，这就是递归的终止条件。

编写递归案例

假如这里有 n 个台阶，每次你可以跨 1 个台阶或者 2 个台阶，请问走这 n 个台阶有多少种走法？如果有 7 个台阶，你可以 2，2，2，1 这样子上去，也可以 1，2，1，1，2 这样子上去，总之走法有很多，那如何用编程求得总共有多少种走法呢？
我们仔细想下，实际上，可以根据第一步的走法把所有走法分为两类，第一类是第一步走了 1 个台阶，另一类是第一步走了 2 个台阶。所以 n 个台阶的走法就等于先走 1 阶后，n-1 个台阶的走法 加上先走 2 阶后，n-2 个台阶的走法。用公式表示就是：

f (n) = f(n  - 1) + f(n - 2)

有了递推公式，递归代码基本上就完成了一半。我们再来看下终止条件。当有一个台阶时，我们不需要再继续递归，就只有一种走法。所以 f(1)=1。这个递归终止条件足够吗？我们可以用 n=2，n=3 这样比较小的数试验一下。
n=2 时，f(2)=f(1)+f(0)。如果递归终止条件只有一个 f(1)=1，那 f(2) 就无法求解了。所以除了 f(1)=1 这一个递归终止条件外，还要有 f(0)=1，表示走 0 个台阶有一种走法，不过这样子看起来就不符合正常的逻辑思维了。所以，我们可以把 f(2)=2 作为一种终止条件，表示走 2 个台阶，有两种走法，一步走完或者分两步来走。
所以，递归终止条件就是 f(1)=1，f(2)=2。这个时候，你可以再拿 n=3，n=4 来验证一下，这个终止条件是否足够并且正确。
我们把递归终止条件和刚刚得到的递推公式放到一起就是这样的：

f(1) = 1;
f(2) = 2;
f(n) = f(n-1)+f(n-2)

有了这个公式，我们转化成递归代码就简单多了。最终的递归代码是这样的：

  if (n == 1) return 1;
  if (n == 2) return 2;
  return f(n-1) + f(n-2);
}

总结：

• 一、什么是递归？
  1.递归是一种非常高效、简洁的编码技巧，一种应用非常广泛的算法，比如DFS深度优先搜索、前中后序二叉树遍历等都是使用递归。
  2.方法或函数调用自身的方式称为递归调用，调用称为递，返回称为归。
  3.基本上，所有的递归问题都可以用递推公式来表示，比如
  f(n) = f(n-1) + 1;
  f(n) = f(n-1) + f(n-2);
  f(n)=n*f(n-1);
• 二、为什么使用递归？递归的优缺点？
  1.优点：代码的表达力很强，写起来简洁。
  2.缺点：空间复杂度高、有堆栈溢出风险、存在重复计算、过多的函数调用会耗时较多等问题。
• 三、什么样的问题可以用递归解决呢？
  一个问题只要同时满足以下3个条件，就可以用递归来解决：
  1.问题的解可以分解为几个子问题的解。何为子问题？就是数据规模更小的问题。
  2.问题与子问题，除了数据规模不同，求解思路完全一样
  3.存在递归终止条件
• 四、如何实现递归？
  1.递归代码编写
  写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，最后将递推公式和终止条件翻译成代码。
  2.递归代码理解
  对于递归代码，若试图想清楚整个递和归的过程，实际上是进入了一个思维误区。
  那该如何理解递归代码呢？如果一个问题A可以分解为若干个子问题B、C、D，你可以假设子问题B、C、D已经解决。而且，你只需要思考问题A与子问题B、C、D两层之间的关系即可，不需要一层层往下思考子问题与子子问题，子子问题与子子子问题之间的关系。屏蔽掉递归细节，这样子理解起来就简单多了。
  因此，理解递归代码，就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。
• 五、递归常见问题及解决方案
  1.警惕堆栈溢出：可以声明一个全局变量来控制递归的深度，从而避免堆栈溢出。
  2.警惕重复计算：通过某种数据结构来保存已经求解过的值，从而避免重复计算。
• 六、如何将递归改写为非递归代码？
  笼统的讲，所有的递归代码都可以改写为迭代循环的非递归写法。如何做？抽象出递推公式、初始值和边界条件，然后用迭代循环实现。
  参考如何用三行代码找到“最终推荐人

实例

实例

• 阶乘

def fact(n):

    if n==1:

        return 1

    return n * fact(n -1)

上面就是一个实现阶乘的递归函数，我们来试一试。

>>> fact(1)
1
>>> fact(5)
120

可能有点懵吧，来看一看计算过程吧：

===> fact(5)

===> 5 * fact(4)

===> 5 * (4 * fact(3))

===> 5 * (4 * (3 * fact(2)))

===> 5 * (4 * (3 * (2 * fact(1))))

===> 5 * (4 * (3 * (2 * 1)))

===> 5 * (4 * (3 * 2))

===> 5 * (4 * 6)

===> 5 * 24

===> 120

• 斐波那契数列

def fib(n):
    if n <2:
         return n
    else:
        return fib(n -1) + fib(n -2)

• 汉诺塔

def hanoti(n,x1,x2,x3):
    if(n == 1):
        print('move:',x1,'-->',x3)
        return
    hanoti(n-1,x1,x3,x2)
    print('move:',x1,'-->',x3)
    hanoti(n-1,x2,x1,x3)