代码随想录三刷day18

最新推荐文章于 2026-06-23 21:03:17 发布

原创最新推荐文章于 2026-06-23 21:03:17 发布 · 467 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #算法 #数据结构 #leetcode #开发语言

力扣题解专栏收录该内容

296 篇文章

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、力扣102. 二叉树的层序遍历
二、力扣107. 二叉树的层序遍历 II
三、力扣199. 二叉树的右视图
四、力扣637. 二叉树的层平均值
五、力扣429. N 叉树的层序遍历
六、力扣515. 在每个树行中找最大值
七、力扣116. 填充每个节点的下一个右侧节点指针
八、力扣117. 填充每个节点的下一个右侧节点指针 II
九、力扣104. 二叉树的最大深度
十、力扣111. 二叉树的最小深度

前言

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

一、力扣102. 二叉树的层序遍历

/**
 * 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 List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        Deque<TreeNode> deq = new LinkedList<>();
        if(root == null){
            return res;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            List<Integer> path = new LinkedList<>();
            int size = deq.size();
            for(int i = 0; i < size; i ++){
                TreeNode p = deq.pollFirst();
                path.add(p.val);
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
            res.add(path);
        }
        return res;
    }
}

二、力扣107. 二叉树的层序遍历 II

在这里插入代码片/**
 * 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 List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        Deque<TreeNode> deq = new LinkedList<>();
        if(root == null){
            return res;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            List<Integer> path = new LinkedList<>();
            int size = deq.size();
            for(int i = 0; i < size; i ++){
                TreeNode p = deq.pollFirst();
                path.add(p.val);
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
            res.add(path);
        }
        Collections.reverse(res);
        return res;
    }
}

三、力扣199. 二叉树的右视图

/**
 * 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 List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        Deque<TreeNode> deq = new LinkedList<>();
        if(root == null){
            return res;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            for(int i = 0; i < size; i ++){
                TreeNode p = deq.pollFirst();
                if(i == size - 1){
                    res.add(p.val);
                }
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
        }
        return res;
    }
}

四、力扣637. 二叉树的层平均值

在这里插入代码片/**
 * 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 List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new LinkedList<>();
        Deque<TreeNode> deq = new LinkedList<>();
        if(root == null){
            return res;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            double count = 0;
            for(int i = 0; i < size; i ++){
                TreeNode p = deq.pollFirst();
                count += p.val;
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
            res.add(count/size);
        }
        return res;
    }
}

五、力扣429. N 叉树的层序遍历

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<Node> deq = new LinkedList<>();
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            List<Integer> path = new LinkedList<>();
            for(int i = 0; i < size; i ++){
                Node p = deq.pollFirst();
                path.add(p.val);
                for(Node n : p.children){
                    if(n != null){
                        deq.offerLast(n);
                    }
                }
            }
            res.add(path);
        }
        return res;
    }
}

六、力扣515. 在每个树行中找最大值

在这里插入代码片/**
 * 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 List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        Deque<TreeNode> deq = new LinkedList<>();
        if(root == null){
            return res;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            int v = Integer.MIN_VALUE;
            for(int i = 0; i < size; i ++){
                TreeNode p = deq.pollFirst();
                v = Math.max(v,p.val);
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
            res.add(v);
        }
        return res;
    }
}

七、力扣116. 填充每个节点的下一个右侧节点指针

在这里插入代码片/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        Deque<Node> deq = new LinkedList<>();
        if(root == null){
            return root;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            Node temp = null;
            for(int i = 0; i < size; i ++){
                Node p = deq.pollFirst();
                if(i == 0){
                    p.next = null;
                    temp = p;
                }else{
                    p.next = temp;
                    temp = p;
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
                if(p.left != null){
                    deq.offerLast(p.left);
                }
            }
        }
        return root;
    }
}

八、力扣117. 填充每个节点的下一个右侧节点指针 II

在这里插入代码片/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        Deque<Node> deq = new LinkedList<>();
        if(root == null){
            return root;
        }
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            Node temp = null;
            for(int i = 0; i < size; i ++){
                Node p = deq.pollFirst();
                if(i == 0){
                    p.next = null;
                    temp = p;
                }else{
                    p.next = temp;
                    temp = p;
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
                if(p.left != null){
                    deq.offerLast(p.left);
                }
            }
        }
        return root;
    }
}

九、力扣104. 二叉树的最大深度

/**
 * 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 int maxDepth(TreeNode root) {
        int res = 0;
        if(root == null){
            return res;
        }
        Deque<TreeNode> deq = new LinkedList<>();
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            res ++;
            for(int i = 0; i < size; i++){
                TreeNode p = deq.pollFirst();
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
        }
        return res;
    }
}

十、力扣111. 二叉树的最小深度

在这里插入代码片/**
 * 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 int minDepth(TreeNode root) {
        int res = 0;
        if(root == null){
            return res;
        }
        Deque<TreeNode> deq = new LinkedList<>();
        deq.offerLast(root);
        while(!deq.isEmpty()){
            int size = deq.size();
            res ++;
            for(int i = 0; i < size; i ++){
                TreeNode p = deq.pollFirst();
                if(p.left == null && p.right == null){
                    return res;
                }
                if(p.left != null){
                    deq.offerLast(p.left);
                }
                if(p.right != null){
                    deq.offerLast(p.right);
                }
            }
        }
        return res;
    }
}