LeetCode递归高频题（十）

大家好，我是方圆
无它，唯手熟尔

21. 合并两个有序链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        //循环结束的条件,当l1为空的时候，返回的l2即为最后结果
        if(l1 == null){
            return l2;
        }
        //理由同上
        if(l2 == null){
            return l1;
        }

        //当l1小于l2的时候，l1那么就将作为最后的答案返回
        //而且，在这里要对其进行递归
        if(l1.val < l2.val){
            //此处头节点已经确定，那么l1的下一个节点
            //是了l1.next还是l2呢，进行递归
            l1.next = mergeTwoLists(l1.next,l2);
            return l1;
        }else{
            l2.next = mergeTwoLists(l1,l2.next);
            return l2;
        }
    }
}

22. 括号生成（回溯法）

class Solution {
    List<String> res = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        dfs(n,n,"");
        return res;
    }

    private void dfs(int left,int right,String curStr){
        if(left == 0 && right == 0){
            res.add(curStr);
        }

        if(left > 0){
            dfs(left - 1,right,curStr + "(");
        }

        if(left < right){
            dfs(left,right - 1,curStr + ")");
        }
    }
}

46. 全排列（回溯法）

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        //用于记录已经选过的数字
        LinkedList<Integer> track = new LinkedList<>();

        //回溯法
        backtarck(nums,track);
        return res;
    }

    private void backtarck(int[] nums,LinkedList<Integer> track){
        //递归结束条件
        if(track.size() == nums.length){
            res.add(new LinkedList<Integer>(track));
        }

        for(int i = 0;i < nums.length;i++){
            //排除已有的数字
            if(track.contains(nums[i])){
                continue;
            }

            //选出一个数字
            track.add(nums[i]);
            //进行下一级的选择
            backtarck(nums,track);

            //递归结束，添加完成后，将元素一个个删除
            //这样才能继续向下找答案
            track.removeLast();
        }
    }
}

101. 对称二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return isMirror(root,root);
    }

    public boolean isMirror(TreeNode t1,TreeNode t2){
        //结束条件，t1、t2都为null时，返回true
        if(t1 == null && t2 == null){
            return true;
        }
        //其中一个不为null时，返回false（结束条件判断的都是左右子树的关系）
        if(t1 == null || t2 == null){
            return false;
        }
        //这里进行递归
        return (t1.val == t2.val)&&isMirror(t1.left,t2.right)&&isMirror(t1.right,t2.left);
    }
}

104. 二叉树的高度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        //结束条件，为空的时候返回0
        if(root == null){
            return 0;
        }else{
            int left = maxDepth(root.left);
            int right = maxDepth(root.right);
            //递归到最后，返回0会根据高度层层加1
            return Math.max(left,right) + 1;
        }
    }
}

226. 翻转二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        //递归结束的条件
        if(root == null){
            return null;
        }

        //若当前节点不为空，则交换它的左右节点
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        //进行递归，交换左右节点的子节点
        invertTree(root.left);
        invertTree(root.right);

        //递归结束，可以返回了
        return root;
    }
}

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

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    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);

        //此种情况为叶子节点，没有发现与pq相等，返回null
        if(left == null && right == null){
            return null;
        }
        //左节点为null的时候，那么返回右节点
        if(left == null){
            return right;
        }
        if(right == null){
            return left;
        }
        //都不为null的时候，直接返回root
        return root;
    }
}

---

多写！多练！