【算法思维训练-剑指Offer联名 二】递归与循环篇
本篇是联名训练的第二篇，主题为递归与循环，如果我们需要重复地多次计算相同的问题，通常可以选择用递归或者循环两种不同的方法。递归是在一个函数的内部调用这个函数自身。而循环则是通过设置计算的初始值及终止条件，在一个范围内重复运算。
递归与循环
循环很常见，就是for、while、do while这样子，我们平时使用的也较为频繁，我们重点关注下递归的优缺点：
- 优点：代码简洁。基于递归实现的代码比基于循环实现的代码要简洁很多，更加容易实现。
- 缺点一：效率较低。递归由于是函数调用自身，而函数调用是有时间和空间的消耗的：每一次函数调用，都需要在内存栈中分配空间以保存参数、返回地址及临时变量，而且往栈里压入数据和弹出数据都需要时间。这就不难理解上述的例子中递归实现的效率不如循环**【时间】。另外，递归中有可能很多计算都是重复的，从而对性能带来很大的负面影响。递归的本质是把一个问题分解成两个或者多个小问题。如果多个小问题存在相互重叠的部分，那么就存在重复的计算【空间】**。
- 缺点二：调用栈溢出。递归还有可能引起更严重的问题：调用栈溢出。前面分析中提到需要为每一次函数调用在内存栈中分配空间，而每个进程的栈的容量是有限的。当递归调用的层级太多时，就会超出栈的容量，从而导致调用栈溢出。
所以在对性能和时间要求不严格，以及限制递归次数的前提下，使用递归比较好，比较代码简洁清爽。反之，如果有强要求的时候，可以考虑使用循环。从递归的优缺点也可以归纳出递归的三大要素：
- 第一要素：明确你这个函数想要干什么。先不管函数里面的代码什么，而是要先明白，你这个函数的功能是什么，要完成什么样的一件事。
- 第二要素：寻找递归结束条件。我们需要找出当参数为啥时，递归结束，之后直接把结果返回，请注意，这个时候我们必须能根据这个参数的值，能够直接知道函数的结果是什么。
- 第三要素：找出函数的等价关系式。我们要不断缩小参数的范围，缩小之后，我们可以通过一些辅助的变量或者操作，使原函数的结果不变。
算法训练
《剑指offer》关于递归与循环的算法训练共有4题：斐波那契数列【难度3】、跳台阶【难度3】、变态跳台阶【难度2】，矩形覆盖【难度3】。
斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n<=39
分析
按照第一篇学习过程中的方法来分析，分为如下几个要点：
- 数列为斐波那契数列，其特点是，某一项的值等于其前两项的和
- 边界条件：n<=39
公式如下：
解法
当然了，最直观的解法当然是直接用递归公式去做：
public class Solution {
public int Fibonacci(int n) {
//设置边界条件
if(n>39||n<0)
return -1;
if(n==0)
return 0;
if(n==1)
return 1;
if(n>1&&n<=39)
return Fibonacci(n-1)+Fibonacci(n-2);
return -1;
}
}
但是提交结果是：
那么该怎么优化呢？不难看出，其实这里做了很多重复的计算，例如f(5)实际上是f(3)+f(4)…一直到f(1)+f(0)。如果能寄存中间值，就不用浪费这些性能了。**如果你使用递归的时候不进行优化，是有非常非常非常多的子问题被重复计算的。因此，使用递归的时候，必要须要考虑有没有重复计算，如果重复计算了，一定要把计算过的状态保存起来。
public class Solution {
public int Fibonacci(int n) {
if(n>39||n<0)
return -1;
if(n==0)
return 0;
if(n==1)
return 1;
int result=0;
int first=0;
int second=1;
for(int i=2;i<=n;i++){
result = first+second;
first=second;
second=result;
}
return result;
}
}
使用循环可以解决重复计算、入栈出栈的时间和空间浪费。
跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
分析
按照第一篇学习过程中的方法来分析，分为如下几个要点：
- 实际Demo举例：如果只有 1 级台阶，那显然只有一种跳法。如果有2级台阶，那就有两种跳的方法了：一种是分两次跳，每次跳1级；另外一种就是一次跳2级。
- 边界条件：共有n个台阶，n为1到n之间的正整数
我们把n级台阶时的跳法看成是n的函数，记为f（n）。当n>2时，第一次跳的时候就有两种不同的选择：一是第一次只跳1级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f（n-1）；另外一种选择是第一次跳2级，此时跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f（n-2）。因此n级台阶的不同跳法的总数f（n）=f（n-1）+f（n-2）。分析到这里，我们不难看出这实际上就是斐波那契数列了。
解法
public class Solution {
public int JumpFloor(int target) {
if(target<1) return -1;
if(target==1) return 1;
else if(target==2) return 2;
else return JumpFloor(target-1)+JumpFloor(target-2);
}
}
以及低性能损耗的循环版本。
public class Solution {
public int JumpFloor(int target) {
if(target<1) return -1;
if(target==1) return 1;
else if(target==2) return 2;
else{
int result=0;
int first=1;
int second=2;
for(int i=3;i<=target;i++){
result = first+second;
first=second;
second=result;
}
return result;
}
}
}
变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
分析
确实有够变态的，不过按照第一篇学习过程中的方法来分析，分为如下几个要点：
- 实际Demo举例：如果只有 1 级台阶，那显然只有一种跳法。如果有2级台阶，那就有两种跳的方法了：一种是分两次跳，每次跳1级；另外一种就是一次跳2级。如果有3级台阶，那就有f(1)+f(2)+一次跳3级共有4种，如果有4级台阶，那就是
- 边界条件：共有n个台阶，n为1到n之间的正整数
我们把n级台阶时的跳法看成是n的函数，记为f（n）。当n>2时，第一次跳的时候就有两种不同的选择：一是第一次只跳1级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f（n-1）；另外一种选择是第一次跳2级，此时跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f（n-2），最后一种选择是第一次跳3级，此时跳法数目等于后面剩下的n-3。因此n级台阶的不同跳法的总数归纳为f（n）=f（n-1）+f（n-2）+f(n-3)…+f(n-n)=f(0)+f(1)+…f(n-1)=f(n-1)+f(n-1)=2*f(n-1)
解法
这个时候
public class Solution {
public int JumpFloorII(int target) {
if(target<1) return -1;
if(target==1) return 1;
else {
return 2*JumpFloorII(target-1);
}
}
}
以及低性能损耗的循环版本。
public class Solution {
public int JumpFloorII(int target) {
if(target<1) return -1;
if(target==1) return 1;
else {
int result=0;
int last=1;
for(int i=2;i<=target;i++){
result=2*last;
last=result;
}
return result;
}
}
}
矩形覆盖
我们可以用2X1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2X1的小矩形无重叠地覆盖一个2Xn的大矩形，总共有多少种方法？比如n=3时，2*3的矩形块有3种覆盖方法：
分析
同样按照之前的方式去分析，不过按照第一篇学习过程中的方法来分析，分为如下几个要点：
- 实际Demo举例：如果只有 1 个矩形，那显然只有1种方法。如果有2个矩形，那就有2种方法了：一种是两个都竖着，另外一种就是两个都横着。如果有3 个矩形，那就有f(1)+f(2)共3种方法。
- 边界条件：共有n个矩形，n为1到n之间的正整数
- 摆放方式：只有两种，竖着放或者横着放。
用第一个1×2小矩形去覆盖大矩形的最左边时有两个选择，竖着放或者横着放。当竖着放的时候，右边还剩下2×2的区域，这种情形下的覆盖方法记为f（2）。接下来考虑横着放的情况。当1×2的小矩形横着放在左上角的时候，左下角必须也横着放一个1×2的小矩形，而在右边还还剩下2×1的区域，这种情形下的覆盖方法记为f（1）
解法
public class Solution {
public int RectCover(int target) {
if(target<1) return 0;
if(target==1) return 1;
else if(target==2) return 2;
else {
return RectCover(target-1)+RectCover(target-2);
}
}
}
以及低性能损耗的循环版本。
public class Solution {
public int RectCover(int target) {
if(target<1) return 0;
if(target==1) return 1;
else if(target==2) return 2;
else {
int result=0;
int first=1;
int second=2;
for(int i=3;i<=target;i++){
result=first+second;
first=second;
second=result;
}
return result;
}
}
}
思考
说实话递归虽然牛逼但还是蛮烧脑的，主要考虑想象能力。估计递归在二叉树上用的比较多吧，不过递归这里也有一些收获：
- 增强如上一篇所说的理论：构建一个简单的Demo，因为有些问题是显而易见的递归，但有些问题不一定看得出来是递归，这个时候就需要去归纳，归纳出规律自然而然就能写出代码
- 代码简洁和性能损耗在递归这里不可兼得啊，一定要依照需求出发，看看目的是什么，场景是什么，什么时候该用递归，什么时候该用循环
- 递归感觉有点儿分治的感觉，结果回归条件。
多练练抽象思维，还是有好处。