递归相关题目

递归

递归，去的时候叫“递”，回来的时候叫“归”；

递归的三个条件

1. 一个问题的解可以分解为几个子问题的解；
2. 这个问题与分解后的子问题，除了数据规模不同，求解思路完全相同
3. 存在递归终止条件

写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，最后将递推公式和终止条件翻译成代码。

递归要注意的两点

1. 递归代码要警惕堆栈溢出

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

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

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

2. 递归代码要警惕重复计算

为了避免重复计算，我们可以通过一个数据结构（比如散列表）来保存已经求解过的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.containsKey(n)) {
    return hasSolvedList.get(n);
  }
  
  int ret = f(n-1) + f(n-2);
  hasSolvedList.put(n, ret);
  return ret;
}

题目

1. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]

ArrayList<Integer> list = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        reverse(head);
        int[] nums = new int[list.size()];
        for(int i =0;i<list.size();i++){
            nums[i]=list.get(i);
        }
        return nums;

    }
    public void reverse(ListNode head){
        if(head == null){
            return;
        }
        reverse(head.next);
        list.add(head.val);
    }

2. pow(x,n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
思路：由于正常思路会导致栈溢出，所以增加map函数，当之前遍历到的时候，就可以直接将结果拿来用。但是这样也是出现了栈溢出~~~

class Solution {
    //递归如何规避栈溢出呢？？？？？
    
    public double myPow(double x, int n) {   
        if(n <0){
            return mypow1(1/x,-n);
        }else{
            return mypow1(x,n);
        }
    }
    HashMap<String,Double> map = new HashMap<String,Double>();
    public double mypow1(double x,int n){
        if(n == 0)
            return 1;
        if(map.containsKey(x+"\t"+n)){
            return map.get(x+"\t"+n);
        }
        double res = mypow1(x,n-1)*x;
        map.put(x+"\t"+n,res);
        return res;
    } 
}

新的思路

class Solution {
    //递归如何规避栈溢出呢？？？？？

    public double myPow(double x, int n) {   
        if(n <0){
            return mypow1(1/x,-n);
        }else{
            return mypow1(x,n);
        }
    }
    public double mypow1(double x,int n){
        if(n == 0)
            return 1;
        double y = mypow1(x,n/2);
        return n%2==0? y*y :y*y*x;
    } 
}

3. 递归乘法

递归乘法。 写一个递归函数，不使用 * 运算符， 实现两个正整数的相乘。可以使用加号、减号、位移，但要吝啬一些。

示例1:
输入：A = 1, B = 10
输出：10
示例2:
输入：A = 3, B = 4
输出：12

class Solution {
    public int multiply(int A, int B) {
        int minNum = Math.min(A,B);
        int maxNum = Math.max(A,B);
        return dfs(minNum,maxNum);
    }
    public int dfs (int minnum,int maxnum){
        if(minnum == 0) return 0;
        if(minnum == 1) return maxnum;
        if(minnum == 2) return maxnum << 1;
        return dfs(2,maxnum) + dfs(minnum-2,maxnum);
    }
}