【数据结构与算法 | 二叉树篇】力扣101, 104, 111，LCR144

Vez'nan的幸福生活

已于 2024-06-06 19:58:49 修改

阅读量209

点赞数 2

文章标签：贪心算法动态规划数据结构线性回归排序算法最小二乘法决策树

于 2024-06-04 20:06:08 首次发布

本文链接：https://blog.csdn.net/2301_80912559/article/details/139452846

版权

1. 力扣101 : 对称二叉树

(1). 题

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

(2). 思路

用队列将二叉树的根节点的左子树和右子树的值记录下来，然后while循环比较.

(3). 解

class Solution {
    Deque<Integer> deque1 = new LinkedList<>();
    Deque<Integer> deque2 = new LinkedList<>();
    public boolean isSymmetric(TreeNode root) {
        boolean flag = true;
        recursionLeft(root.left);
        recursionRight(root.right);
        while (!deque1.isEmpty() && !deque2.isEmpty()) {
            if (deque1.poll() != deque2.poll()) {
                flag = false;
            }
        }
        return flag;
    }
    public void recursionLeft(TreeNode root) {
        if (root == null) {
            deque1.offer(110);
            return;
        }
        deque1.offer(root.val);
        recursionLeft(root.left);
        recursionLeft(root.right);
    }

    public void recursionRight(TreeNode root) {
        if (root == null) {
            //这处代码是需要的, 不然光靠根左右是无法确定是否是对称的
            deque2.offer(110);
            return;
        }
        deque2.offer(root.val);
        recursionRight(root.right);
        recursionRight(root.left);
    }
}

(4). 思路2

使用递归判断.

(5). 解2

class Solution {
    //递归
    public boolean isSymmetric(TreeNode root) {
        return recursion(root.left, root.right);
    }
    private boolean recursion(TreeNode left, TreeNode right){
        //如果需要比较的节点都为null, 返回true
        if (left == null && right == null) {
            return true;
        }
        //这种情况显然是false, 但为了保证第三个if判断不出现空指针异常, 所以单独提前判断
        if (left == null && right != null || left != null && right == null) {
            return false;
        } 
        //此时left, right节点都不为空, 所以比较二者的值
        if (left.val == right.val){
            //并继续比较两节点的孩子的值是否相等
            return recursion(left.left, right.right) && recursion(left.right, right.left);
        } else {
            return false;
        }
    }
}

2. 力扣104 : 二叉树的最大深度

(1). 题

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

输入：root = [1,null,2]
输出：2

提示：

树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

(2). 思路

递归，从根节点开始，树的最大高度就是，根节点+左孩子的高度/右孩子的高度.而该左孩子的高度为左孩子+左孩子的左孩子的高度/左孩子的右孩子高度...

(3). 解

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int a = maxDepth(root.left);
        int b = maxDepth(root.right);
        a = a > b ? a : b;
        return 1 + a;
    }
}

(4). 思路2

后序遍历+栈最大长度.

(5). 解2

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        //后序遍历 + 栈的最大深度
        TreeNode cur = root;
        Deque<TreeNode> deque = new LinkedList<>();
        int depth = 0;
        TreeNode pop = null;
        while (cur != null || !deque.isEmpty()){
            if (cur != null) {
                deque.push(cur);
                depth = depth > deque.size() ? depth : deque.size();
                cur = cur.left;
            } else {
                TreeNode peek = deque.peek();
                if (peek.right == null || peek.right == pop){
                    pop = deque.pop();
                } else {
                    cur = peek.right;
                }
            }
        }
        return depth;
    }
}

(6). 思路3

队列+层序遍历，返回层数.

(7). 解3

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        //层序遍历
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int size = 1;
        int n = 0;
        int height = 0;
        TreeNode p;
        //只要队列不为空
        while (!queue.isEmpty()){
            for (int i = 0; i < size; i++) {
                p = queue.poll();
                if (p.left != null) {
                    queue.offer(p.left);
                    n++;
                }
                if (p.right != null) {
                    queue.offer(p.right);
                    n++;
                }
            }
            size = n;
            n = 0;
            height++;
        }
        return height;
    }
}

3. 力扣111 : 二叉树的最小深度

(1). 题

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000

(2). 思路

与求解二叉树的最大二叉树代码不同的是，题目要求根节点到最近叶子节点的高度，对于根节点只有左子树(或只有右子树)这种情况来说，需要额外讨论，因为此时不能直接返回1，而是要返回1+右子树的高度.

(3). 解

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null) {
            return 1 + minDepth(root.right);
        }
        if (root.right == null) {
            return 1 + minDepth(root.left);
        }
        int a = minDepth(root.left);
        int b = minDepth(root.right);
        a = a < b ? a : b;
        return a + 1;
    }
}

4. LCR144 : 翻转二叉树

(1). 题

给定一棵二叉树的根节点 root，请左右翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [5,7,9,8,3,2,4]
输出：[5,9,7,4,2,3,8]

提示：

树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

(2). 思路1

迭代思路，该题的关键就是注意到，翻转二叉树，其实就是翻转二叉树的每一个非叶子节点. 队列数据结构，存储需要翻转的非叶子节点.

(3). 解1

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        recursion(root);
        return root;
    }
    private void recursion(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root);
        TreeNode p;
        TreeNode a;
        TreeNode b;
        while (!deque.isEmpty()){
            p = deque.poll();
            if (p.left == null && p.right == null) {
                continue;
            }
            if (p.left != null) {
                deque.offer(p.left);
            }
            if (p.right != null) {
                deque.offer(p.right);
            }
            a = p.left;
            b = p.right;
            p.left = b;
            p.right = a;
        }
    }
    
}

(4). 思路2

递归，思路与迭代一致.

(5). 解2

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        recursion(root);
        return root;
    }
    private void recursion(TreeNode root) {
        if (root == null){
            return;
        }
        TreeNode p = root.left;
        TreeNode q = root.right;
        root.left = q;
        root.right = p;
        recursion(root.left);
        recursion(root.right);
    }
    
}