递归：如何用三行代码找到“最终推荐人”

递归：如何用三行代码找到“最终推荐人”

推荐注册返回佣金的功能，用户A推荐用户B来注册，用户B又推荐用户C来注册，所以，用户C的最终推荐人为用户A，用户B的最终推荐人也是用户A

我们会通过数据库来记录这种推荐关系，在表中，记录两行数据，一行为actor_if表示用户id,referrer_id为推荐人id,问题来了，给定一个用户id,如何查找这个用户的最终推荐人？即递归

递归

数据结构中最难理解的知识点是动态规划和递归

所有的递归问题都可以用递归公式$f(n)=f(n-1)+1,其中f(1)=1$来表示

递归需要满足的三个条件

1.一个问题的解可以分解为几个子问题的解

2.这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样

3.存在递归终止条件

如何编写递归代码

写出递推公式，找到终止条件

例子：假如有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(0)=1,因为f(0)=1表示0个台阶有一种走法不符合逻辑思维，表示f(2)=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两层之间的关系

递归代码要警惕堆栈溢出

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

如何避免出现堆栈溢出？

通过在代码中限制递归调用的最大深度的方式来解决，递归调用超过一定的深度（比如1000）之后，不继续往下进行，直接报错

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

int f(int n){
  ++depth;
  if(depth > 1000) throw exception;
  
  if ( n == 1) return 1;
return f(n-1) +1;
}

代码要警惕重复计算

为了避免重复计算，通过一个数据结构（比如散列表）来保存已经求解过的f(k)，当递归调用到f(k)的时候，先看是否已经求解过，如果是，直接从散列表中取值返回，不需要重复计算

比如第二个台阶的问题，f(3)被计算过多次数

public int f(int n){
  if (n ==1) return 1;
  if(n ==2) return 2;
  
  //haoSolvedList 可以理解成一个map，key是n，value是f(n)
  if (haoSolvedList.containsKey(n)){
    return hasSolvedList.get(n);
  }
  int ret = f(n-1)+f(n-2);
  haoSolvedList.put(n,ret);
  return ret;
}

在时间效率上，递归代码有很多函数调用，当这些函数调用的数量较大时，就会积累一个可观的时间成本，空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，为O(n)

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

看电影的例子，使用$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;
}

本质上没有改变，也没有解决某些问题，徒增复杂度

如何找到“最终推荐人”

long findRootReferrerId(long actorId){
  Long referrerId = select referrer_id from [table] where actor_id = actorId;
  if (referrerId == null) return actorId;
  return findRootReferrerId(referrerId)
}

有两个问题：

一，如果递归很深，可能会有堆栈溢出的问题

二，如果数据库中有脏数据，还需要处理由此产生的无限递归问题

都可以使用限制递归深度解决，还有自动检测“A-B-C-A”环的存在

检测环构造一个散列表，每次获取到上层推荐人就去散列表中查，没有查到的话就加入，如果存在表示存在环，每一次查询都是一个散列表