【算法刷题day15】Leetcode:各种层序遍历、226.翻转二叉树、101. 对称二叉树

已于 2024-04-04 12:06:11 修改
阅读量361 收藏 5
点赞数 5
分类专栏： 代码随想录（2024上半年） 文章标签： 算法 leetcode 职场和发展
于 2024-04-03 15:55:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45022758/article/details/137339509
版权

文章目录

草稿图网站
java的Deque

Leetcode 层序遍历

题目：102.二叉树的层序遍历
题目：107. 二叉树的层序遍历 II
题目：199.二叉树的右视图
题目：637.二叉树的层平均值
题目：429.N叉树的层序遍历
题目：515.在每个树行中找最大值
题目：116.填充每个节点的下一个右侧节点指针
题目：117.填充每个节点的下一个右侧节点指针II
题目：104.二叉树的最大深度
解析：代码随想录解析

解题思路

代码

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 ArrayList<List<Integer>>();
        if (root == null)
            return res;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> item = new ArrayList<Integer>();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                item.add(node.val);
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(item);
        }
        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 ArrayList<List<Integer>>();
        if (root == null)
            return res;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> item = new ArrayList<Integer>();
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                item.add(node.val);
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(item);
        }
        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 ArrayList<Integer>();
        if (root == null)
            return res;
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.add(root);
        res.add(root.val);
        while (!deque.isEmpty()){
            int size = deque.size();
            for (int i = 0; i < size; i++){
                TreeNode node = deque.poll();
                if (node.left != null)  deque.add(node.left);
                if (node.right != null)  deque.add(node.right);
            }
            if (!deque.isEmpty())
                res.add(deque.getLast().val);
        }
        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 ArrayList<Double>();
        if (root == null)
            return res;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            double sum = 0;
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(sum / 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 ArrayList<List<Integer>>();
        if (root == null)
            return res;
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            List<Integer> item = new ArrayList<Integer>();
            for (int i = 0; i < size; i++){
                Node node = queue.poll();
                item.add(node.val);
                for (Node n : node.children){
                    if (n != null)
                        queue.add(n);
                }
            }
            res.add(item);
        }
        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 ArrayList<Integer>();
        if (root == null)
            return res;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            int max = Integer.MIN_VALUE;
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                max = Math.max(max, node.val);
                if (node.left != null)  queue.add(node.left);
                if (node.right != null)  queue.add(node.right);
            }
            res.add(max);
        }
        return res;
    }
}

116.填充每个节点的下一个右侧节点指针

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) {
        if (root == null)
            return root;
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            Node pre = queue.poll();
            if (pre.left != null)   queue.add(pre.left);
            if (pre.right != null)  queue.add(pre.right);
            for (int i = 1; i < size; i++){
                Node cur = queue.poll();
                if (cur.left != null)   queue.add(cur.left);
                if (cur.right != null)  queue.add(cur.right);
                pre.next = cur;
                pre = cur;
            }
        }
        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 depth = 0;
        if (root == null)
            return depth;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            depth++;
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
        }
        return depth;
    }
}

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) {
        if (root == null)
        	return 0;
        int minDepth = Integer.MAX_VALUE;
        int depth = 0;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            depth++;
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if (node.left == null && node.right == null)
                    minDepth = Math.min(minDepth, depth);
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
        }
        return minDepth==Integer.MAX_VALUE ? 0 : minDepth;
    }
}

//优化，不需要全部遍历完，因为是一层一层找下去，所以第一个叶子就是最低的
/**
 * 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) {
        if (root == null)
            return 0;
        int depth = 0;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            depth++;
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if (node.left == null && node.right == null)
                    return depth;
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
        }
        return depth;
    }
}

总结

暂无

Leetcode 226.翻转二叉树

题目：226.翻转二叉树
解析：代码随想录解析

解题思路

使用局部遍历存储交换后的，然后稀里糊涂就过了。

代码

/**
 * 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 TreeNode invertTree(TreeNode root) {
        if (root == null)
            return root;
        TreeNode tmp = invertTree(root.left);
        root.left = invertTree(root.right);
        root.right = tmp;
        return root;
    }
}

//更能体现前序遍历和后续遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null)
            return root;
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;
    }
    private void swapChildren(TreeNode node){
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}

//层序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null)
            return root;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                swapChildren(node);
                if (node.left != null)  queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
        }
        return root;
    }
    private void swapChildren(TreeNode node){
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}

//前序
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null)
            return root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            swapChildren(node);
            if (node.left != null) stack.push(node.left);
            if (node.right != null) stack.push(node.right);
        }
        return root;
    }
    private void swapChildren(TreeNode node){
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}

//统一深度遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null)
            return root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.peek();
            if (node != null){
                stack.pop();
                if (node.left != null) stack.push(node.left);
                if (node.right != null) stack.push(node.right);
                stack.push(node);
                stack.push(null);
            }else{
                stack.pop();
                node = stack.pop();
                swapChildren(node);
            }
        }
        return root;
    }
    private void swapChildren(TreeNode node){
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}

总结

暂无

Leetcode 101. 对称二叉树

题目：101. 对称二叉树
解析：代码随想录解析

解题思路

遍历遍历遍历

代码



//递归
/**
 * 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);
    }
    public boolean compare(TreeNode left, TreeNode right){
        if (left == null && right == null)
            return true;
        else if (left == null || right == null || left.val != right.val)
            return false;
        else
            return compare(left.left, right.right) && compare(left.right, right.left);
    }
}

//使用队列
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null)
            return true;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root.left);
        queue.add(root.right);
        while (!queue.isEmpty()){
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if (left == null && right == null)
                continue;
            if (left == null || right == null || left.val != right.val)
                return false;
            queue.add(left.left);
            queue.add(right.right);
            queue.add(left.right);
            queue.add(right.left);
        }
        return true;
    }
}

//使用栈
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null)
            return true;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root.left);
        stack.push(root.right);
        while (!stack.isEmpty()){
            TreeNode left = stack.pop();
            TreeNode right = stack.pop();
            if (left == null && right == null)
                continue;
            if (left == null || right == null || left.val != right.val)
                return false;
            stack.push(left.left);
            stack.push(right.right);
            stack.push(left.right);
            stack.push(right.left);
        }
        return true;
    }
}

总结

暂无

Allmight_Q
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
12-3 LeetCode：226. 翻转二叉树.mp4
05-30
12-3 LeetCode：226. 翻转二叉树.mp4
12-5 LeetCode：101. 对称二叉树.mp4
05-30
12-5 LeetCode：101. 对称二叉树.mp4
Day15 二叉树part02 102.二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
Alexanderyaphets的博客
12-26 443
102.二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
day15|Leetcode:● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2
qerwtrt4t的博客
12-21 61
二叉树
代码随想录算法训练营Day15 | 二叉树(2/9) LeetCode 层序遍历 226.翻转二叉树 101.对称二叉树
记录学习每一天！
08-17 70
二叉树练习第二天，思路最重要！
代码随想录【day 14 二叉树】| 层序遍历 226.翻转二叉树 101.对称二叉树
weixin_43891814的博客
02-08 676
代码随想录【day 14 二叉树】| 层序遍历 226.翻转二叉树 101.对称二叉树
代码随想录训练营Day15：层序遍历、226.翻转二叉树 、101.对称二叉树
minixiaoxiaozhu的博客
10-06 306
层序遍历、226.翻转二叉树 、101.对称二叉树
代码随想录打卡day15|102. 二叉树的层序遍历226. 翻转二叉树101. 对称二叉树
weixin_56718399的博客
11-09 268
力扣打卡
Leetcode刷题 Day15 102. 二叉树的层序遍历 226. 翻转二叉树 101. 对称二叉树
weixin_54199919的博客
05-13 40
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。给定一个二叉树，检查它是否是镜像对称的。
Day15|Leetcode 102.二叉树的层序遍历 Leetcode 226. 翻转二叉树 Leetcode 101. 对称二叉树
weixin_72635630的博客
11-09 185
本题目如果仔细思考的话，是只能用后序遍历，因为我们要返回的值是root，前序和中序都是左右两边的树节点都没有对比完成就返回是没有可能做对的。这个题目难点在对题目的理解上，如果理解正确，那这道题目就很简单了，也可以跟着代码，把遍历顺序画一遍就明白了。如果这个题目懂了，那么下面这九道题目也就可以做了。换汤不换药，一样的，只是二叉树种类不同，同样适用。就是遍历的最大层数，想想什么时候最大就解决了。和上一道类似，想想什么时候取最小。今天好累，好迷 end。
力扣Day15（2.15）| 第六章 二叉树 （层序遍历 226.翻转二叉树 101. 对称二叉树）
qq_43053703的博客
02-15 121
有点难，需要二刷时此部分需要细致一点，一刷本模块理解思路，为主，独立写代码为辅
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
python python_leetcode面试题解之第107题二叉树的层序遍历II
python入门-leetcode面试题解之第226题翻转二叉树.zip
05-31
python入门 python入门_leetcode面试题解之第226题翻转二叉树
catwang01#Algorithm#Leetcode 226. 翻转二叉树1
07-25
使用 preorder、inorder、postorder、levelorder均可解法1: preorder dfs解法1: 实现：递归def invertT
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 379
【代码】力扣LCP 08.剧情触发时间。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 475
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
【排序算法】总结篇
SWsunlight的博客
06-08 913
排序对比
力扣416 分割等和子集 Java版本
最新发布
m0_47066863的博客
06-14 327
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
递归实现二叉树的层序遍历
12-19
以下是使用递归实现二叉树的层序遍历的Python代码示例： ```python class TreeNode: def __init__(self, value=0, left=None, right=None): self.value = value self.left = left self.right = right def ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Allmight_Q

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值