leetcode刷穿二叉树

Posted 2021-06-02 深林无鹿

这里有leetcode题集分类整理！！！

文章目录

• 这里有leetcode题集分类整理！！！
• • 每日五道二叉树（一）
  • • 1、leetcode 226. 翻转二叉树
    • 2、leetcode 101. 对称二叉树
    • 3、leetcode 104. 二叉树的最大深度
    • 4、leetcode 559. N 叉树的最大深度
    • 5、leetcode 111. 二叉树的最小深度

每日五道二叉树（一）

1、leetcode 226. 翻转二叉树

解题思路：

翻转二叉树，可以采用递归的思想，每次递归调用的时候，不断交换左右孩子，在return，最后返回root就是左右孩子交换的结果啦，步骤如下：
1、创建新的左孩子为左孩子树进行翻转
2、创建新的右孩子为右孩子树进行翻转
3、将左右孩子调换

code：

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

2、leetcode 101. 对称二叉树

解题思路：
方法一：递归

因为做了上面翻转二叉树，看到这道题的第一时间，想先翻转二叉树，再与原二叉树进行比较的。结果示例二就WA了。也不是很清楚为啥。。换个思路，递归做一下，将大问题化为小问题，判断是否镜像对称：
1、首先考虑递归结束条件：

• 需要进行判断的左右孩子同时为空，return true
• 需要进行判断的左右孩子不同时为空，return false
• 需要进行判断的左右孩子同时不为空

2、针对1中的最后一个讨论：

• 比较左右孩子的值是否相等
• 直接递归判断左孩子的左孩子与右孩子的右孩子是否相等
• 直接递归判断左孩子的右孩子与右孩子的左孩子是否相等
• 比较上面两种情况，一种不符合就 return false

3、都满足情况则 return true

code：

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

    boolean compare(TreeNode node1, TreeNode node2) {
        if (node1 == null && node2 == null) return true;
        else if (node1 == null || node2 == null) return false;
        else return node1.val == node2.val && compare(node1.left, node2.right) && compare(node1.right, node2.left);
    }
}

方法二：（迭代）
解题思路：

迭代的思想就是需要维护一个队列，来模仿上面的思路。
首先创建一个队列，然后
判断逻辑：和递归一样
队列操作：
1、将左孩子的左孩子和右孩子的右孩子加入队列
2、将左孩子的右孩子和右孩子的左孩子加入队列
核心思路：如果为镜像，队列每次弹出的前两个节点元素必须相等

code：

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root, root);
    }

    boolean compare(TreeNode l, TreeNode r) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(l);
        queue.offer(r);
        while (!queue.isEmpty()) {
            l = queue.poll();
            r = queue.poll();
            if (l == null && r == null) continue;
            else if (l == null || r == null || l.val != r.val) return false;
            
            queue.offer(l.left);
            queue.offer(r.right);
            
            queue.offer(l.right);
            queue.offer(r.left);
        }
        return true;
    }
}

3、leetcode 104. 二叉树的最大深度

递归实现（dfs）
解题思路：

递归思想十分清晰：
1、首先明确递归结束条件： 如果节点为空 ，返回高度为 0
2、返回当前节点中左孩子的高度和右孩子的高度中最大的那一个+1 返回。

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

迭代实现（bfs）
解题思路：

维护一个队列，在每层遍历完都进行层数加一，最后返回层数就ok

class Solution {
	public int maxDepth(TreeNode root) {
        int ans = 0;
        if (root == null) return ans;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while (!q.isEmpty()) {
            int sz = q.size();
            for (int i = 0; i < sz; i ++) {
                TreeNode node = q.poll();
                if (node.left != null) q.offer(node.left);
                if (node.right != null) q.offer(node.right);
            }
            ans ++;	// 遍历完一层 ++
        }
        return ans;
    }
}

4、leetcode 559. N 叉树的最大深度

方法一：递归（dfs）
解题思路

递归终止条件为节点为null 返回 0
递归返回 当前节点所有孩子的最大高度

class Solution {
    public int maxDepth(Node root) {
        if (root == null) return 0;
        int ans = 0;
        for (Node node : root.children) {
            ans = Math.max(ans, maxDepth(node));
        }
        return ans + 1;
    }
}

方法二：迭代（bfs）
解题思路同上一道题一模一样，不给出来了。

5、leetcode 111. 二叉树的最小深度

方法一：dfs
解题思路：

在递归的时候不断返回最小值即可，类似上面的题。
一定一定一定要判断好边界条件。
一定一定一定要判断好边界条件。
一定一定一定要判断好边界条件。

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;

        if (root.left == null && root.right == null) return 1;

        int ans = Integer.MAX_VALUE;
        if (root.left != null) {
            ans = Math.min(ans, minDepth(root.left));
        } 
        if (root.right != null) {
            ans = Math.min(ans, minDepth(root.right));
        }
        return ans + 1;
    }
}

方法二：迭代（bfs）（推荐）
解题思路：

维护一个队列，只要遇到叶子节点就返回层数：
判断叶子节点： 左右孩子都为空

这个方法优于dfs 因为大部分情况都可以提前结束，时间换空间思想

code

class Solution {
    public int minDepth(TreeNode root) {
        int level = 0;
        if (root == null) return level;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty()) {
            int sz = q.size();
            for (int i = 0; i < sz; i ++) {
                TreeNode node = q.poll();
                // 遇到叶子节点即可返回当前层数
                // 因为是层序遍历，访问到叶子节点就是最小层数
                if (node.left == null && node.right == null) return level + 1;
                if (node.left != null) q.offer(node.left);
                if (node.right != null) q.offer(node.right);
            }
            level ++;
        }
        return level;
    }
}