数据结构与算法——递归

递归是一种应用非常广泛的算法(或者说是一种编程技巧)

关于递归算法，这里有一个生活当中非常贴切的一个例子：周末你带着女朋友去电影院看电影，女朋友问你，咱们现在坐在第几排啊？电影院里面太黑了，看不清，没法数，现在你该怎么办？这个时候递归就排上了用场。于是你就问前面一排的人他是第几排，你想只要在他的数字上加一，就知道自己在哪一排了。但是，前面的人也看不清啊，所以他也问他前面的人。就这样一排一排的往前问，直到问到第一排的人，说我在第一排，然后再这样一排一排的再把数字传回来。直到你前面的告诉你他在哪一排，于是你就知道了答案了。

这就是一个非常标准的递归求解问题的分解过程，去的过程叫“递”，回来的过程叫“归”。基本上，所有的递归问题都可以用递推公式来表示。刚刚这个生活当中的例子，我们用递推公式将它表示出来就是这样的：

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

f(n)表示你想知道自己在哪一排，f(n-1)表示前面一排所在的排数，f(1)=1表示第一排的人知道自己在第一排。有了这个递推公式，我们就可以轻松的将它改为递归代码，如下： 

int f(int n)
{
    if (n == 1)
        return 1;
    return f(n-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；当只有两个台阶时，我们同样不需要再递归，只有两种走法，所以f(2)=2；这样一来，随着递归的进行，存在了递归的终止条件：f(1)=1,f(2)=2。我们把递归终止条件和刚刚得到的递推公式放到一起就很容易得到了递归代码：

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

这里总结一下，写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，最后将递推公式和终止条件翻译成代码。在编写递归代码的时候，只要遇到递归，我们就把它抽象成一个递推公式，不用想一层一层的调用关系，不要试图用人脑去分解递归的每个步骤。

在编写递归算法时，我们还需牢记递归的4条基本法则：

• 基准情形。必须总要有某些基准情形，它无须递归就能解出。
• 要有进展。对于那些需要递归求解的情形，每一次递归调用就必须要使状况朝向一种基准情形推进。
• 设计法则。假设所有的递归调用都能运行。
• 合成效益法则。在求解一个问题的同一实例时，切勿在不同的递归调用中做重复性的工作。

递归代码要警惕堆栈溢出

在之前“栈”那篇博客当中，我们了解到了函数调用栈的概念，我们知道函数调用会使用栈来保存临时变量。每调用一个函数，都将临时变量封装为栈帧压入内存栈，等函数执行完成返回时，才出栈。系统栈或者虚拟机栈空间的大小一般都不大。如果递归求解的数据规模很大，导致调用层次很深，一直将栈帧入栈，就会有堆栈溢出的风险。

当堆栈溢出时便会出现如下堆栈报错信息：

0x0026A5C9 处有未经处理的异常(在 Test.exe 中): 0xC00000FD: Stack overflow (参数: 0x00000001, 0x00292F5C)。

那么，应该如何避免出现堆栈溢出呢？

我们可以通过在代码中限制递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度(比如1000)之后，我们就不继续往下再递归了，直接返回错误。还是电影院那个例子，我们可以改造成下面这个样子，就可以避免堆栈溢出了。

int depth = 0;    // 全局变量，表示递归的深度。

int f(int n)      // 为了举例说明，未考虑边界条件(n <= 0)
{
    ++depth;
    if (depth > 1000) throw exception;
    
    if (n == 1) return 1;
    return f(n - 1) + 1;
}

但是这种做法并不能完全解决问题，因为最大允许的递归深度跟当前线程剩余的栈空间大小有关，事先无法计算。如果实时计算，代码过于复杂，就会影响代码的可读性。所以，如果最大深度比较小，比如10、50，就可以用这种方法，否则这种方法并不是很实用。

另外我们可以通过将递归函数当中所需的数据，在不影响代码执行的条件下定义为全局静态变量，这样就减少了函数调用时，压入堆栈当中栈帧的大小了，从而减轻了内存的负担。

递归代码要警惕重复计算

除了堆栈溢出以外，使用递归时还会出现重复计算的问题。刚才我们将的上台阶的例子当中，如果我们将递归过程逐一分解之后，就会发现，当我们计算f(5)的时候，需要先计算出f(4)和f(3)，而计算f(4)还需要计算f(3)，因此，f(3)就被计算了很多次，这就是重复计算的问题。

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

按照上面的思路，我们来改造一下刚才的代码：

public int f(int n)        // 恕我无能，还没看到C++的hash_map容器这里只能给出java的实现
{                          // 迟早有一天，我会潇洒的走过来，改掉这个代码，相信我！！！
    if (n == 1) return 1;
    if (n == 2) return 2;

    // hasSolvedList可以理解成一个Map，key是n，value是f(n)

    if (hasSolvedList.containsKey(n))
    {
        return hasSolvedList.get(n);
    }

    int ret = f(n - 1) + f(n - 2);
    hasSovledList.put(n, ret);
    return ret;
}

除了堆栈溢出、重复计算这两个常见的问题。递归代码还有很多别的问题。在时间效率上，递归代码里多了很多函数调用，当这些函数调用的数据量较大时，就会积聚成一个可观的时间成本。在空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，需要额外考虑这部分的开销，比如我们最开始所举的电影院递归代码，空间复杂度并不是O(1)，而是O(n)。

如何将递归代码改写为非递归代码？

之前我们了解到，我们将问题转化为递归的形式解决时，不必考虑具体子问题的执行细节，只需考虑递归公式和终止条件即可，这就是递归的优点：递归代码的表达力极强，写起来也非常简洁；但是递归也存在空间复杂度高、有堆栈溢出的风险、存在重复计算、过多的函数调用会耗时较多等问题。所以在开发过程中，我们要根据实际情况来选择是否需要用递归的方式来实现。

接下来我们将电影院例子的递归代码改写为非递归代码：

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;
}

那是不是所有的递归代码都可以改为这种迭代循环的非递归写法呢？笼统的讲，是的。因为递归本身就是借助栈来实现的，只不过我们使用的栈是系统或者虚拟机本身提供的，我们没有感知罢了。如果我们自己在内存堆上实现栈，手动模拟入栈、出栈过程，这样任何递归代码都可以改写成看上去不是递归代码的样子。

但是这种思路实际上是讲递归改为了“手动”递归，本质没有改变，而且也没有解决前面讲到的某些问题，徒增了实现的复杂度。

标签：return,递归,int,代码,一排,算法,数据结构,递推
来源： https://blog.csdn.net/weixin_42570248/article/details/88305801