数据结构与算法之美-入门篇-10-递归

最新推荐文章于 2021-12-12 15:58:18 发布

zhangjiequan

最新推荐文章于 2021-12-12 15:58:18 发布

阅读量169

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/winzjqwin/article/details/104524954

版权

数据结构与算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

数据结构与算法之美-入门篇-10-递归

如何理解“递归”？
递归需要满足的三个条件
如何编写递归代码？
课后思考
Ps:算法面试通关40讲(覃超)关于递归的讲述
- 代码模板
- leetcode题目

如何理解“递归”？

递归是难的，王争也认为最难理解的知识点一个是动态规划，另一个就是递归。
递归是一种应用非常广泛的算法（或者编程技巧）。之后我们要讲的很多数据结构和算法的编码实现都要用到递归，比如 DFS 深度优先搜索、前中后序二叉树遍历等等。所以，搞懂递归非常重要，否则，后面复杂一些的数据结构和算法学起来就会比较吃力。

举例说明递归，周末你带着女朋友去电影院看电影，女朋友问你，咱们现在坐在第几排啊？电影院里面太黑了，看不清，没法数，现在你怎么办？
于是你就问前面一排的人他是第几排，你想只要在他的数字上加一，就知道自己在哪一排了。但是，前面的人也看不清啊，所以他也问他前面的人。就这样一排一排往前问，直到问到第一排的人，说我在第一排，然后再这样一排一排再把数字传回来。直到你前面的人告诉你他在哪一排，于是你就知道答案了
这就是一个非常标准的递归求解问题的分解过程，去的过程叫“递”，回来的过程叫“归”。
递推公式：

f(n)=f(n-1)+1 其中，f(1)=1

递归代码：

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

递归需要满足的三个条件

一个问题的解可以分解为几个子问题的解
这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样
存在递归终止条件

如何编写递归代码？

我个人觉得，写递归代码最关键的是写出递推公式，找到终止条件，剩下将递推公式转化为代码就很简单了。(但写递归代码的前提是，你能判断出，“这个问题可以用递归来解决，更进一步，要判断用递归来解决比较适合”)

举例说明：
假如这里有 n 个台阶，每次你可以跨 1 个台阶或者 2 个台阶，请问走这 n 个台阶有多少种走法？如果有 7 个台阶，你可以 2，2，2，1 这样子上去，也可以 1，2，1，1，2 这样子上去，总之走法有很多，那如何用编程求得总共有多少种走法呢？

把递归终止条件和刚刚得到的递推公式放到一起就是这样的：

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

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

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

写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，最后将递推公式和终止条件翻译成代码。

递归的思维和传统的大脑运行思维的不同

刚讲的电影院的例子，我们的递归调用只有一个分支，也就是说“一个问题只需要分解为一个子问题”，我们很容易能够想清楚“递“和”归”的每一个步骤，所以写起来、理解起来都不难。

但是，当我们面对的是一个问题要分解为多个子问题的情况，递归代码就没那么好理解了。

像我刚刚讲的第二个例子，人脑几乎没办法把整个“递”和“归”的过程一步一步都想清楚。

计算机擅长做重复的事情，所以递归正和它的胃口。而我们人脑更喜欢平铺直叙的思维方式。当我们看到递归时，我们总想把递归平铺展开，脑子里就会循环，一层一层往下调，然后再一层一层返回，试图想搞清楚计算机每一步都是怎么执行的，这样就很容易被绕进去。

对于递归代码，这种试图想清楚整个递和归过程的做法，实际上是进入了一个思维误区。很多时候，我们理解起来比较吃力，主要原因就是自己给自己制造了这种理解障碍。那正确的思维方式应该是怎样的呢？

如果一个问题 A 可以分解为若干子问题 B、C、D，你可以假设子问题 B、C、D 已经解决，在此基础上思考如何解决问题 A。而且，你只需要思考问题 A 与子问题 B、C、D 两层之间的关系即可，不需要一层一层往下思考子问题与子子问题，子子问题与子子子问题之间的关系。屏蔽掉递归细节，这样子理解起来就简单多了。

因此，编写递归代码的关键是，只要遇到递归，我们就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。

Ps: 只想中间的一层，和终止条件的一层，不要一层一层想。

递归和数学归纳法

上面的Ps的内容，有点像数学归纳法，数学归纳法也是知道前面的几个结果（终止条件的一层），猜想假设第n层满足，那么能推导n+1也是满足的，则这个猜想成立。

搜索了一下，也有人写了类似的观点，数学归纳法和递归、递归和数学归纳法。特别赞同《递归和数学归纳法》这篇文章中的“使用数学归纳法设计递归程序最大的好处就是可以使设计者摆脱对递推的顾虑。因为你设计的代码必定隐含着递推的步骤。直接根据你的分析文字转化为代码即可”。因为我也是有这个顾虑。

递归代码要警惕堆栈溢出

我在“栈”那一节讲过，函数调用会使用栈来保存临时变量。每调用一个函数，都会将临时变量封装为栈帧压入内存栈，等函数执行完成返回时，才出栈。系统栈或者虚拟机栈空间一般都不大。如果递归求解的数据规模很大，调用层次很深，一直压入栈，就会有堆栈溢出的风险。

比如前面的讲到的电影院的例子，如果我们将系统栈或者 JVM 堆栈大小设置为 1KB，在求解 f(19999) 时便会出现如下堆栈报错：java.lang.StackOverflowError。
我们可以通过在代码中限制递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度（比如 1000）之后，我们就不继续往下再递归了，直接返回报错。
但这种做法并不能完全解决问题，因为最大允许的递归深度跟当前线程剩余的栈空间大小有关，事先无法计算。如果实时计算，代码过于复杂，就会影响代码的可读性。所以，如果最大深度比较小，比如 10、50，就可以用这种方法，否则这种方法并不是很实用。
Ps:
结论是，没什么好办法很好地处理递归的堆栈溢出。真实工程中，能不用递归，就不要用。怎么不用？用其它算法，例如把递归转成递推。

递归代码要警惕重复计算

刚刚走楼梯的例子
在这里插入图片描述
从图中，我们可以直观地看到，想要计算 f(5)，需要先计算 f(4) 和 f(3)，而计算 f(4) 还需要计算 f(3)，因此，f(3) 就被计算了很多次，这就是重复计算问题。

为了避免重复计算，我们可以通过一个数据结构（比如散列表）来保存已经求解过的 f(k)。当递归调用到 f(k) 时，先看下是否已经求解过了。如果是，则直接从散列表中取值返回，不需要重复计算，这样就能避免刚讲的问题了。

除了堆栈溢出、重复计算这两个常见的问题（空间、时间两个角度）。递归代码还有很多别的问题。

在时间效率上，递归代码里多了很多函数调用，当这些函数调用的数量较大时，就会积聚成一个可观的时间成本。在空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，需要额外考虑这部分的开销，比如我们前面讲到的电影院递归代码，空间复杂度并不是 O(1)，而是 O(n)。（Ps,这两段不是在重复上面的常见的问题么？没有表达出什么新的信息？）

怎么将递归代码改写为非递归代码？

我们刚说了，
递归有利有弊，
利：递归代码的表达力很强，写起来非常简洁；（Ps：这个“利”的吸引力不足。。其实递归要结合后面的数据结构才比较有用，如DFS 深度优先搜索、前中后序二叉树遍历，不能单纯为了递归与递归）
弊：空间复杂度高、有堆栈溢出的风险、存在重复计算、过多的函数调用会耗时较多等问题（Ps：这个“弊”就真的是很弊了）
所以，在开发过程中，我们要根据实际情况来选择是否需要用递归的方式来实现。
那我们是否可以把递归代码改写为非递归代码呢？比如刚才那个电影院的例子，我们抛开场景，只看 f(x) =f(x-1)+1 这个递推公式。我们这样改写看看：

int f(int n) {
  int ret = 1;
  for (int i = 2; i <= n; ++i) {
    ret = ret + 1;
  }
  return ret;
}

同样，第二个例子也可以改为非递归的实现方式。

int f(int n) {
  if (n == 1) return 1;
  if (n == 2) return 2;
  
  int ret = 0;
  int pre = 2;
  int prepre = 1;
  for (int i = 3; i <= n; ++i) {
    ret = pre + prepre;
    prepre = pre;
    pre = ret;
  }
  return ret;
}

（Ps,或者用个数组保存每一个阶梯的结果，这样就不用两个临时变量。好处是直观，和可以最后翻查中间结果，坏处是空间复杂度由O1变成On了）
那是不是所有的递归代码都可以改为这种迭代循环的非递归写法呢？

笼统地讲，是的。
因为递归本身就是借助栈来实现的，只不过我们使用的栈是系统或者虚拟机本身提供的，我们没有感知罢了。如果我们自己在内存堆上实现栈，手动模拟入栈、出栈过程，这样任何递归代码都可以改写成看上去不是递归代码的样子。
但是这种思路实际上是将递归改为了“手动”递归，本质并没有变，而且也并没有解决前面讲到的某些问题，徒增了实现的复杂度。
（Ps,手动模拟那肯定可以啦。
但是，是不是任何代码都可以改为上面的这种简单的非递归（我的理解是递推）的写法呢?应该是不可以的吧？）