推荐注册返佣金这个功能我想你应该不陌生吧？现在很多APP都有这个功能，这个功能中，用户A推荐用户B来注册，用户B又推荐用户C来注册。我们可以说，用户C的最终推荐人为用户A，用户B的最终推荐人为用户A，而用户A没有最终推荐人
一般来说，我们会通过数据库来记录这种推荐关系，在数据库表中，我们可以记录两行数据，其中 actor_id 表示用户 id, referrer-id 表示推荐人 id
基于这个背景，我的问题是？带着这个问题，我们来学习今天的内容，递归(Recursion)!
如何理解“递归”？
从我自己学习数据结构和算法的经历来看，我个人觉得，有两个最难理解的知识点，一个是 ，另一个就是。
递归是一种应用非常广泛的算法（编程技巧）。很多数据结构和算法的编码实现都要用到递归，比如DFS深度优先搜索、前中后序二叉树遍历等等。所以，搞懂递归非常重要，否则，后面复杂一些的数据结构和算法学起来就会比较吃力。
不过，别看我说了这么多，递归本身可是一点都不“高冷”，咱们生活中就有很多用到递归的例子。
周末你带着女朋友去电影院看电影，女朋友问你，咱们现在坐在第几排啊？电影院里面太黑了，看不清，没法数，现在你怎么办？
递归就开始派上用场了。于是你问前面一排的人他是第几排，你想只要在他的数字上加一，就知道自己在哪一排了。但是前面的人也看不清啊，所以他也问他前面的人。就这样一排一排的往前问，直到问到第一排的人，说我在第一排，然后再这样一排一排再把数字传回来。直到你前面的人告诉你他在那一排，于是你就知道答案了。
这是一个非常标准的递归求解的分解过程，去的过程“递”，回来的过程叫“归”。基本上，所有的递归问题都可以用递推公式来表示。刚刚这个生活中的例子，我们用递推公式将它表示出来是这样的：
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;
}
递归需要满足的三个条件
刚刚这个例子是非常典型的递归，那究竟什么样的问题可以用递归来解决呢？只要同时满足以下三个条件，就可以用递归来解决。
1.一个问题的解可以分解为几个子问题的解
何为子问题？子问题就是数据规模更小的问题。比如，前面讲的电影院的例子，你要知道，“自己在哪一排”的问题，可以分解为“前一排的人在哪一排”这样一个子问题。
2.这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样
比如电影院那个例子，你求解“自己在哪一排”的思路，和前面一排人求解“自己在哪一排”的思路是一模一样的。
3.存在递归终止条件
把问题分解为子问题，把子问题再分解为子子问题，一层一层分解下去，不能存在无限循环，这就需要有终止条件。
还是电影院的例子，第一排的人不需要再继续询问任何人，就知道自己在哪一排，也就是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);
代码：
inf 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两层之间的关系即可，不需要一层一层往下思考子问题与子子问题，子子问题与子子子问题之间的关系。屏蔽掉递归细节，这样理解起来就简单多了。
因此，编写递归代码的关键是，只要遇到递归，我们就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑分解递归的每个步骤。
递归代码要警惕堆栈溢出
在实际软件开发中，编写递归代码时，我们会遇到很多问题，比如堆栈溢出。而堆栈溢出会造成系统性崩溃，后果非常严重。为什么递归代码容易造成堆栈溢出呢？又改如何预防堆栈溢出呢？
函数调用会使用栈来保存临时变量。每调用一个函数，都会将临时变量封装为栈帧压入内存栈，等函数执行完成返回时，才出栈，系统栈或者虚拟机栈控件一般都不大。如果递归求解的数据规模很大，调用层次很深，一直压入栈，就会有堆栈溢出的风险。
比如前面所讲的电影院的例子，如果我们将系统栈或者JVM堆栈大小设置为1KB，在求解f(19999)时就会出现堆栈报错
那么，如何避免出现堆栈溢出呢？
我们可以通过在代码中递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度（比如1000）之后，我们就不继续往下再递归了，直接返回报错。还是电影院那个例子，我们可以改造成下面这样子，就可以避免堆栈溢出。
// 全局变量，表示递归的深度
int depth = 0;
inf f(int n) {
++depth;
if (depth > 1000) throw exception;
if (n==1) return 1;
return f(n-1) + 1;
}
但这种做法并不能完全解决问题，因为最大允许的递归深度跟当前线程剩余的栈空间大小有关，事先无法计算，如果实时计算，代码过于复杂，影响代码可读性。所以，如果最大深度比较小，比如 10，50 可以用这种方法。否则这种方法不实用
递归代码要警惕重复计算
除此之外，使用递归时还会出现重复计算的问题。刚才我讲的第二个递归代码的例子，如果我们把整个递归过程分解一下的话，那就是这样的：
[图片上传失败...(image-806d36-1563369670168)]
从图中，我们可以直观看到，想要计算f(5)，需要先计算f(4)和f(3)，而计算f(4)还需要计算f(3)，因此f(3)就被计算很多次，这就是重复计算问题。
为了避免重复计算，我们可以通过一个数据结构（散列表）来保存已经求解过的f(k)。当递归调用f(k)，先看下是否已经求解过了。如果是，则直接从散列表返回，不需要重复计算。
按照上面的思路，改造一下代码：
public int f(int n) {
if (n==1) return 1;
if (n==2) return 2;
// hasSolvedList 可以理解成一个Map，key是n，value是f(n)
if (hasSolvedList.containKey(n)) {
return hasSolvedList.get(n);
}
int ret = f(n-1) + f(n-2);
hasSolvedList.put(n, ret);
return ret;
}
除了堆栈溢出、重复计算这两个常见的问题，递归代码还有很多别的问题。
在时间效率上，递归代码多了很多函数调用，当这些函数调用的数量较大时，就会积聚成一个可观的时间成本。在空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，需要额外考虑这部分开销。
怎么将递归代码改写为非递归代码
递归有利有弊，利是递归代码表达力很强，写起来非常简洁；而弊就是空间复杂度高，有堆栈溢出的风险、存在重复计算、过多的函数调用会耗时较多等问题。所以，在开发时要根据实际情况来选择是否用递归方式来实现。
学习来源：https://time.geekbang.org/column/article/41440