【算法】递归

递归

• 递归实现的原理：
  一个递归函数的调用过程相似于多个函数的嵌套的调用，只不过调用函数和被调用函数是同一个函数。为了保证递归函数的正确执行，系统需设立一个工做栈。具体地说，递归调用的内部执行过程以下：
  1. 运动开始时，首先为递归调用创建一个工做栈，其结构包括值参、局部变量和返回地址；
  2. 每次执行递归调用以前，把递归函数的值参、局部变量的当前值以及调用后的返回地址压栈；
  3. 每次递归调用结束后，将栈顶元素出栈，使相应的值参和局部变量恢复为调用前的值，而后转向返回地址指定的位置继续执行。
• 注意：在咱们了解了递归的基本思想及其数学模型以后，咱们如何才能写出一个漂亮的递归程序呢？我认为主要是把握好以下三个方面：
  1. 明确递归函数的做用；
  2. 明确递归终止条件与对应的解决办法；
  3. 找出函数的等价关系式，提取重复的逻辑缩小问题规模。
• 递归三步走：
  • 明确函数功能：要清楚你写这个函数是想要作什么；
  • 寻找递归出口：递归必定要有结束条件，否则会永远递归下去，禁止套娃；
  • 找出递推关系：开始实现递归，一步一步递推出最终结果。

明确函数功能

第一步，明确这个函数的功能是什么，它要完成什么样的一件事。
而这个功能，是彻底由你本身来定义的。也就是说，咱们先无论函数里面的代码是什么、怎么写，而首先要明白，你这个函数是要用来干什么的。

例如，求解任意一个数的阶乘：
要作出这个题，
第一步，要明确即将要写出的这个函数的功能为：算n的阶乘。

//算n的阶乘（假设n不为0）
int f(int n) {
    
}

寻找递归出口（初始条件）

递归：就是在函数实现的内部代码中，调用这个函数自己。因此，咱们必需要找出递归的结束条件，否则的话，会一直调用本身，一直套娃，直到内存充满。

• 必须有一个明确的结束条件。由于递归就是有“递”有“归”，因此必须又有一个明确的点，到了这个点，就不用“递下去”，而是开始“归来”。

第二步，咱们须要找出当参数为什么值时，递归结束，以后直接把结果返回。
（通常为初始条件，而后从初始条件一步一步扩充到最终结果）

注意：这个时候咱们必须能根据这个参数的值，可以直接知道函数的结果是什么。

让咱们继续完善上面那个阶乘函数。
第二步，寻找递归出口：
当n=1时，咱们可以直接知道f(1)=1；
那么递归出口就是n=1时函数返回1。
以下：

//算n的阶乘（假设n不为0）
int f(int n) {
    if(n == 1) {
        return 1;
    }
}

固然，当n=2时，咱们也是知道f(2)等于多少的，n=2也能够做为递归出口。递归出口可能并不惟一的。

找出递推关系

第三步，咱们要从初始条件一步一步递推到最终结果。（能够类比数学概括法，多米诺骨牌）

• 初始条件：f(1) = 1
• 递推关系式：f(n) = f(n-1)*n

这样就能够从n=1，一步一步推到n=2，n=3...

// 算n的阶乘（假设n不为0）
int f(int n) {
    if(n = 1) {
        return n;
    }
    // 把f(n)的递推关系写进去
    return f(n-1) * n;
}

到这里，递归三步走就完成了，那么这个递归函数的功能咱们也就实现了。
可能初学的读者会感受很奇妙，这就能算出阶乘了？

那么，咱们来一步一步推一下。
f(1)=1
f(2)=f(1)*2=2
f(3)=f(2)*3=2*3=6
...
你看看是否是解决了，n都能递推出来！

例题

斐波那契数列

斐波那契数列的是这样一个数列：一、一、二、三、五、八、1三、2一、34....，即第一项 f(1) = 1,第二项 f(2) = 1.....,第 n 项目为 f(n) = f(n-1) + f(n-2)。求第 n 项的值是多少。

• 明确函数功能：f(n)为求第n项的值

  // 1.f(n)为求第n项的值
  int f(int n) {
  
  }

• 寻找递归出口：f(1)=1,f(2)=1

  // 1.f(n)为求第n项的值
  int f(int n) {
      // 2.递归出口
      if(n <= 2) {
          return 1;
      }
  }

• 找出递推关系：f(n) = f(n-1)+f(n-2)

  // 1.f(n)为求第n项的值
  int f(int n) {
      // 2.递归出口
      if(n <= 2) {
          return 1;
      }
      // 3.递推关系
      return f(n-1) + f(n-2);
  }

小青蛙跳台阶

一只青蛙一次能够跳上1级台阶，也能够跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

• 明确函数功能：f(n)为青蛙跳上一个n级的台阶总共有多少种跳法

  int f(int n) {
  
  }

• 寻找递归出口：f(0)=0,f(1)=1

  int f(int n) {
      // 递归出口
      if(n <= 1) {
          return n;
      }
  }

• 找出递推关系：f(n) = f(n-1)+f(n-2)

  int f(int n) {
      // 递归出口
      if(n <= 2) {
          return 1;
      }
      // 递推关系
      return f(n-1) + f(n-2);
  }

递归优化思路

自顶向下

上面说了那么多，都是自底向上的
（我比较习惯自底向上，由于比较符合数学概括法，顺着推）

例如，阶乘能够理解为f(n)一步一步分解为f(n-1)...直到f(1)，一步步化小，这样也是能够的。

重复计算

其实递归当中有不少子问题被重复计算。

对于斐波那契数列，f(n) = f(n-1)+f(n-2)。
递归调用的状态图以下：

其中，递归计算时f(6)、f(5)...都被重复了不少次，这是极大的浪费，当n越大，因重复计算浪费的就越多，因此咱们必需要进行优化。

• 优化思路：
  • 创建一个数组，将子问题的计算结果保存起来。
  • 判断以前是否计算过：
    • 计算过，取出来用
    • 没有计算过，再递归计算
• 实例：
  • 把n做为数组下标，f(n)做为值。
    例如arr[n] = f(n)。
  • f(n)尚未计算过的时候，咱们让arr[n]等于一个特殊值。
    例如arr[n] = -1。
  • 当咱们要判断的时候，
    • 若是 arr[n] = -1，则证实f(n)没有计算过；
    • 不然，f(n)就已经计算过了，且f(n) = arr[n]。
      直接把值取出来用就好了。

代码以下：

// 咱们实现假定 arr 数组已经初始化好的了。
int f(int n) {
    if(n <= 1) {
        return n;
    }
    //先判断有没计算过
    if(arr[n] != -1) {
        //计算过，直接返回
        return arr[n];
    }else {
        // 没有计算过，递归计算,而且把结果保存到 arr数组里
        arr[n] = f(n-1) + f(n-1);
        reutrn arr[n];
    }
}