手撕算法——递归

递归及相关题型

递归在力扣刷题中经常用到，最常见的就是使用递归来遍历二叉树。因此今天总结一下递归求解问题的套路以及常考的面试题，能力有限，如有不对大家多多指教。

递归解题思路

递归，就是在函数内部调用函数本身，因此递归适用于求解可以将一个问题拆分为一个个相同子问题的题目。如二叉树的遍历可以拆分求解左子树的遍历和右子树的遍历两个子问题。我们将递归解题的套路归结为以下三点：
（1）考虑递归终止条件是什么
（2）当前应该做什么
（3）交给递归去做什么
（4）返回结果是什么
以二叉树遍历为例子

public List<Integer> preorderTraversal(TreeNode root) {
        //(1) 判断递归终止条件
        if(root==null){
            return list;
        }
        //（2）当前应该做什么
        list.add(root.val);
		
		//(3) 交给递归去做什么
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        
        //(4)返回结果是什么
        return list;
    }
}

相关面试题

使用递归遍历二叉树

先序遍历

public class Solution {
    List<Integer> list=new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
  
        if(root==null){
            return list;
        }
     
        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        
        return list;
    }
}

中序遍历

public class Solution {
     List<Integer> list=new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root==null){
            return list;
        }
        inorderTraversal(root.left);
        list.add(root.val);
        inorderTraversal(root.right);  
       
        return list;
    }
}

后序遍历

public class Solution {

     List<Integer> list=new ArrayList<>();
     public List<Integer> postorderTraversal(TreeNode root) {
        if(root==null){
            return list;
        }
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        list.add(root.val);
        return list;
    }
}

递归乘法

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

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

class Solution {
    /*
    A*B等价于B个A相加
    */
    public int multiply(int A, int B) {
        int res=helper(A,B);
        return res;
    }

    public int helper(int A,int B){
       	//(1) 递归终止条件
        if(A==0||B==0){
            return 0;
        }
        //(2)当前要做什么
        //(3)交给递归做什么
        //(4)返回值是什么
        return A+helper(A,B-1);
    }
}

括号

面试题 08.09. 括号
括号。设计一种算法，打印n对括号的所有合法的（例如，开闭一一对应）组合。

说明：解集不能包含重复的子集。

例如，给出 n = 3，生成结果为：

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res=new ArrayList<>();
        helper(res,0,0,n,"");
        return res;
    }
    /*
    left记录左括号的个数
    right记录右括号的个数
    什么时候循环终止
        左右括号数相等，并且等于括号数n，终止循环
    什么时候能加入左括号？
        如果左括号的个数小于括号的个数，可以加入做括号
    什么时候可以加入右括号
        如果右括号的个数小于左括号的个数，可以加入右括号
    */
    public void helper(List<String> res,int left,int right,int n,String s){
        //(1)递归终止条件是什么
        if(left==right&&left==n){
            res.add(new String(s));
        }
        //(2)当前需要做什么
        //(3)交给递归做什么
        if(left<n){
            helper(res,left+1,right,n,s+"(");
        }
        if(right<left){
            helper(res,left,right+1,n,s+")");
        }
		
		//(4)返回结果是什么？ 这里是对list进行操作，记录了每次递归的结果，因此不需要有返回值
    }
}