算法：递归相关题目

递归相关题目

一、70. 爬楼梯

解法一：递归+记忆化搜索

    public int climbStairs(int n) {
        if (n<2) return n;
        int[] a = new int[n+1];
        a[1] = 1;
        a[2] = 2;
        return climbStairs(n, a);
    }

    private int climbStairs(int n, int[] a) {
        if (a[n]!=0) return a[n];
        a[n] = climbStairs(n-1, a) + climbStairs(n-2, a);
        return a[n];
    }

二、22. 括号生成

解法一：递归

    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        solve(0, 0, n, new StringBuilder(), res);
        return res;
    }

    private void solve(int left, int right, int n, StringBuilder sb, List<String> res) {
        if (left==n) {
            res.add(sb.toString());
            return;
        }
        if (right<n) {
            sb.append('(');
            solve(left, right+1, n, sb, res);
            sb.deleteCharAt(sb.length()-1);
        }
        if (left<right) {
            sb.append(')');
            solve(left+1, right, n, sb, res);
            sb.deleteCharAt(sb.length()-1);
        }
    }

三、226. 翻转二叉树

3.1 解法一：递归，原地翻转

    public TreeNode invertTree(TreeNode root) {
        return solve(root);
    }

    private TreeNode solve(TreeNode node) {
        if (node==null) return null;
        TreeNode left = solve(node.right);
        node.right = solve(node.left);
        node.left = left;
        return node;
    }

优化:

    public TreeNode invertTree(TreeNode root) {
        if (root==null) return null;
        TreeNode left = invertTree(root.right);
        root.right = invertTree(root.left);
        root.left = left;
        return root;
    }

四、98. 验证二叉搜索树

4.1 中序遍历+递归

    private Long pre = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        if (root==null) return true;
        if (!isValidBST(root.left)) {
            return false;
        }
        if (root.val<=pre) {
            return false;
        }
        pre = (long)root.val;
        return isValidBST(root.right);
    }

五、104. 二叉树的最大深度

5.1 递归

    public int maxDepth(TreeNode root) {
        return solve(root, 0);
    }

    private int solve(TreeNode node, int n) {
        if (node==null) {
            return n;
        }
        return Math.max(solve(node.left, n+1), solve(node.right, n+1));
    }

六、111. 二叉树的最小深度

5.2 解法一：递归

    public int minDepth(TreeNode root) {
        if (root==null) return 0;
        if (root.left==null && root.right==null) return 1;
        int depth = Integer.MAX_VALUE;
        if (root.left!=null) {
            depth = Math.min(minDepth(root.left), depth);
        }
        if (root.right!=null) {
            depth = Math.min(minDepth(root.right), depth);
        }
        return depth + 1;
    }

5.2 解法二：BFS

    public int minDepth(TreeNode root) {
        if (root==null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.addLast(root);
        int n = 1;
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i=0; i<size; i++) {
                TreeNode node = deque.pop();
                if (node.left==null && node.right==null) return n;
                if (node.left!=null) deque.addLast(node.left);
                if (node.right!=null) deque.addLast(node.right);
            }
            n++;
        }
        return n;
    }

七、236. 二叉树的最近公共祖先

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root==null || root==p || root ==q) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left==null && right==null) {
            return null;
        }else if (left!=null && right!=null) {
            return root;
        }else if (left!=null && right==null) {
            return left;
        }else {
            return right;
        }
    }

八、105. 从前序与中序遍历序列构造二叉树

8.1 递归

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTree(preorder, inorder, 0, preorder.length-1, 0, inorder.length-1);
    }
    private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
        if (p1>p2) return null;
        TreeNode root = new TreeNode(preorder[p1]);
        int k = -1;
        for (int x=i1; x<=i2; x++) {
            if (inorder[x]==preorder[p1]) {
                k = x;
                break;
            }
        }
        /** 通过前序的节点，在中序遍历中可以确定左子树的长度 */
        int num = k - i1;
        root.left = buildTree(preorder, inorder, p1+1, p1+num, i1, i1+num-1);
        root.right = buildTree(preorder, inorder, p1+num+1, p2, i1+num+1, i2);
        return root;
    }

8.2 使用哈希表进行优化

    private Map<Integer, Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for (int i=0; i<inorder.length; i++) {
            map.put(inorder[i], i);
        }
        return buildTree(preorder, inorder, 0, preorder.length-1, 0, inorder.length-1);
    }
    private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
        if (p1>p2) return null;
        TreeNode root = new TreeNode(preorder[p1]);
        /*int k = -1;
        for (int x=i1; x<=i2; x++) {
            if (inorder[x]==preorder[p1]) {
                k = x;
                break;
            }
        }*/
        int k = map.get(preorder[p1]);
        /** 通过前序的节点，在中序遍历中可以确定左子树的长度 */
        int num = k - i1;
        root.left = buildTree(preorder, inorder, p1+1, p1+num, i1, i1+num-1);
        root.right = buildTree(preorder, inorder, p1+num+1, p2, i1+num+1, i2);
        return root;
    }

九、77. 组合

9.1 递归

    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        solve(n, k, 0, 0, new Integer[k], result);
        return result;
    }

    private void solve(int n, int k, int i, int l, Integer[] a, List<List<Integer>> list) {
        if (l>=k) {
            list.add(Arrays.asList(a.clone()));
            return;
        }
        for (int j=i; j<=n-k+l; j++) {
            a[l] = j+1;
            solve(n, k, j+1, l+1, a, list);
        }
    }

十、46. 全排列

10.1 递归

    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> resList = new ArrayList<>();
        Set<Integer> set = new HashSet<>();
        int k = nums.length;
        solve(0, k, new Integer[k], resList, nums, set);
        return resList;
    }

    private void solve(int level, int k, Integer[] a, List<List<Integer>> list, int[] nums, Set<Integer> set) {
        if (level>=k) {
            list.add(Arrays.asList(a.clone()));
            return;
        }
        for (int j=0; j<nums.length; j++) {
            if (set.contains(nums[j])) continue;
            set.add(nums[j]);
            a[level] = nums[j];
            solve(level+1, k, a, list, nums, set);
            set.remove(nums[j]);
        }

    }

十一、47. 全排列 II

解法一：先排序，再递归处理

    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res =new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);
        solve(0, n, nums, res, new Integer[n]);
        return res;
    }

    private void solve(int l, int n, int[] nums, List<List<Integer>> res, Integer[] a) {
        if (l>=n) {
            res.add(Arrays.asList(a.clone()));
            return;
        }
        for (int j=0;j<nums.length;) {
            a[l] = nums[j];
            int[] nextNums = createNextNums(nums, j);
            solve(l+1, n, nextNums, res, a);
            j++;
            while (j<nums.length && nums[j]==nums[j-1]) j++;
        }

    }

    private int[] createNextNums(int[] nums, int j) {
        int[] a = new int[nums.length-1];
        int i=0;
        for (int k=0; k<nums.length; k++) {
            if (k==j) continue;
            a[i++] = nums[k];
        }
        return a;
    }