Day 15 | 二叉树的层序遍历 / 226. 翻转二叉树 / 101. 对称二叉树 / 100. 相同的树 / 572. 另一棵树的子树

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量387 收藏 5
点赞数 7
分类专栏： 刷题集 文章标签： java leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44120081/article/details/135173731
版权

二叉树的层序遍历

二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现

Leetcode 102. 二叉树的层序遍历

题目链接：102. 二叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        if(root != null){
            queue.add(root);
        }
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size > 0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
                size--;
            }
            result.add(list);
        }
        return result;
    }
}

Leetcode 107. 二叉树的层序遍历 II

题目链接：107. 二叉树的层序遍历 II

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return result;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size > 0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
                size--;
            }
            result.add(list);
        }
        Collections.reverse(result);
        return result;
    }
}

优化解法， 最后不需要反转

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> result = new LinkedList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return result;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size > 0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
                size--;
            }
            result.addFirst(list);
        }
        return result;
    }
}

Leetcode 199. 二叉树的右视图

题目链接：199. 二叉树的右视图

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return result;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            TreeNode node = null;
            for(int i = 1; i <= size; i++){
                 node = queue.poll();
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
            result.add(node.val);
        }
        return result;
    }
}

Leetcode 637. 二叉树的层平均值

题目链接：637. 二叉树的层平均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            double sum = 0.0;
            for(int i = 1; i <= size; i++){
                TreeNode node = deque.poll();
                sum += node.val;
                if(node.left != null){
                    deque.add(node.left);
                }
                if(node.right != null){
                    deque.add(node.right);
                }
            }
            result.add(sum / size);
        }
        return result;
    }
}

Leetcode 429. N叉树的层序遍历

题目链接：429. N叉树的层序遍历

P.S. 被题目示例误导了，以为输入的是一长串掺杂 null 的元素集合

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<Node> deque = new LinkedList<>();
        if(root == null){
            return result;
        }
        deque.add(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            List<Integer> list = new ArrayList<>();
            for(int i = 1; i <= size; i++){
                Node node = deque.poll();
                list.add(node.val);
                List<Node> children = node.children;
                if(children == null || children.size() == 0){
                    continue;
                }
                for(Node child : children){
                    if(child != null){
                        deque.add(child);
                    } 
                }
            }
            result.add(list);
        }
        return result;
    }
}

Leetcode 515. 在每个树行中找最大值

题目链接：515. 在每个树行中找最大值

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> deque = new LinkedList<>();
        if(root == null){
            return result;
        }
        deque.add(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            int max = Integer.MIN_VALUE;
            for(int i = 1; i <= size; i++){
                TreeNode node = deque.poll();
                // 或者：max = Math.max(max, node.val);
                if(node.val > max){
                    max = node.val;
                }
                if(node.left != null){
                    deque.add(node.left);
                }
                if(node.right != null){
                    deque.add(node.right);
                }
            }
            result.add(max);
        }
        return result;
    }
}

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

题目链接：116. 填充每个节点的下一个右侧节点指针

看题解，有用类似双指针的解法。但是我觉得我的这个解法简单一些。

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return root;
        }
        Deque<Node> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            Node nextNode = null;
            for(int i = 1; i <= size; i++){
                Node node = deque.poll();
                node.next = nextNode;
                if(node.right != null){
                    deque.add(node.right);
                }
                if(node.left != null){
                    deque.add(node.left);
                }
                nextNode = node;
            }
        }
        return root;
    }
}

Leetcode 117. 填充每个节点的下一个右侧节点指针II

题目链接：117. 填充每个节点的下一个右侧节点指针II

上一题是完美二叉树，本题是普通二叉树，其实没有任何差别，解法一模一样

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return root;
        }
        Deque<Node> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            Node nextNode = null;
            for(int i = 1; i <= size; i++){
                Node node = deque.poll();
                node.next = nextNode;
                if(node.right != null){
                    deque.add(node.right);
                }
                if(node.left != null){
                    deque.add(node.left);
                }
                nextNode = node;
            }
        }
        return root;        
    }
}

Leetcode 104. 二叉树的最大深度

题目链接：104. 二叉树的最大深度

class Solution {
    public int maxDepth(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        if(root != null){
            deque.add(root);
        }
        int depth = 0;
        while(!deque.isEmpty()){
            int size = deque.size();
            depth++;
            for(int i = 1; i <= size; i++){
                TreeNode node = deque.poll();
                if(node.left != null){
                    deque.add(node.left);
                }
                if(node.right != null){
                    deque.add(node.right);
                }
            }
        }
        return depth;        
    }
}

Leetcode 111. 二叉树的最小深度

题目链接：111. 二叉树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        if(root != null){
            deque.add(root);
        }
        int depth = 0;
        while(!deque.isEmpty()){
            int size = deque.size();
            depth++;
            for(int i = 1; i <= size; i++){
                TreeNode node = deque.poll();
                if(node.left == null && node.right == null){
                    return depth;
                }
                if(node.left != null){
                    deque.add(node.left);
                }
                if(node.right != null){
                    deque.add(node.right);
                }
            }
        }
        return depth;        
    }
}

Leetcode 226. 翻转二叉树

题目链接：226. 翻转二叉树

本题关键在于遍历顺序。针对二叉树的问题，解题之前一定要想清楚究竟是前中后序遍历，还是层序遍历。

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

    public void swap(TreeNode root) {
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

这道题使用层序遍历也可以。

Leetcode 101. 对称二叉树

题目链接：101. 对称二叉树

思路

第一想法是，层序遍历，用两个队列，分别从左到右和从右到左依次遍历，并对比node的value。或者两次递归，分别左中右遍历和右中左遍历，并对比node的value。但其实并不需要两个队列，也不是用中序遍历。

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

或者把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较。

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 false;
        }
        if(right == null && left != null){
            return false;
        }
        if(left == null && right == null){
            return true;
        }
        if(left.val != right.val){
            return false;
        }
        boolean outside = compare(left.left, right.right);
        boolean inside = compare(left.right, right.left);
        return outside && inside;
    }
}

Leetcode 100. 相同的树

题目链接：100. 相同的树

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        return compare(p, q);
    }

    public boolean compare(TreeNode left, TreeNode right){
        if(left == null && right != null){
            return false;
        }
        if(right == null && left != null){
            return false;
        }
        if(left == null && right == null){
            return true;
        }
        if(left.val != right.val){
            return false;
        }
        boolean leftCompare = compare(left.left, right.left);
        boolean rightCompare = compare(left.right, right.right);
        return leftCompare && rightCompare;
    }
}

Leetcode 572. 另一棵树的子树

题目链接：572. 另一棵树的子树

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root == null){
            return false;
        }
        return compare(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
    }

    public boolean compare(TreeNode left, TreeNode right){
        if(left == null && right != null){
            return false;
        }
        if(right == null && left != null){
            return false;
        }
        if(left == null && right == null){
            return true;
        }
        if(left.val != right.val){
            return false;
        }
        boolean leftCompare = compare(left.left, right.left);
        boolean rightCompare = compare(left.right, right.right);
        return leftCompare && rightCompare;
    }
}
zzz好好学习
关注
专栏目录
代码随想录算法训练营第day15|二叉树层序遍历、 226.翻转二叉树 ●、101.对称二叉树 2
qq_60513199的博客
03-10 1085
这道题目我们也可以使用迭代法，但要注意，这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。层序遍历一个二叉树。给定一个 N 叉树，返回其节点值的层序遍历。
代码随想录算法训练营 day15 | 二叉树层序遍历、226.翻转二叉树、101. 对称二叉树
weixin_42179093的博客
07-31 309
这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的，只要把队列原封不动的改成栈就可以了。注意上面最后一种情况，我没有使用else，而是else if， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。
算法训练day15|层序遍历|226. 翻转二叉树|101. 对称二叉树
weixin_45628782的博客
03-15 212
这题过得莫名其妙的，马后炮的想，只有两种情况要加next，一是同一父节点下的左右节点，二是相邻父节点的右节点和左节点，这一切的前提，都是题目给了这是一个完美二叉树。这个代码可以解决上一题，其实层序遍历的时候，能遍历到每一层的所有节点，只需要用一个指针记录pre即可。其实就是遍历所有节点，翻转左右子树。前序中序后序层序遍历都是可以的，但是中序遍历的递归算法不可以。暂时只学层序遍历的迭代法，后面的几个题目都建立在层序遍历的模板上写。层序遍历要每一层分开装到二维数组中。这题看完题解了，明天再来写一遍。
算法训练day11 | php | 102.层序遍历 ， 226.翻转二叉树 ， 101.对称二叉树 2
a8917cwr的博客
03-29 173
二叉树章节
2024/3/21--代码随想录算法训练营day15|层序遍历、226.翻转二叉树、101.对称二叉树
qq_46277517的博客
03-21 214
力扣链接 力扣链接
算法打卡day13|二叉树篇02|Leetcode 102.二叉树的层序遍历、226.翻转二叉树、101. 对称二叉树
改变从现在开始
03-10 902
JAVA算法|二叉树篇02|Leetcode 102.二叉树的层序遍历、226.翻转二叉树、101. 对称二叉树
LeetCode刷题day12||二叉树层序遍历&&226.翻转二叉树&&101. 对称二叉树--二叉树
wangjianhs的博客
10-15 224
对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
Day 14 | 层序遍历、226.翻转二叉树、101.对称二叉树
baidu_41638844的博客
10-06 170
理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。，出队 len 个元素，即该层元素遍历完毕，遍历过程中将下一层节点全部入队。首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！比较的是两个子树的里侧和外侧的元素是否相等。采用的递归的思路，依次翻转每个节点的左右孩子。翻转二叉树，即需要交换每个节点的左右孩子。遍历树，将一层节点全部入队后，对于二叉树是否对称，
代码随想录算法训练营day15 | 层序遍历 10，226.翻转二叉树，101.对称二叉树 2
2301_77450803的博客
04-19 363
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
【代码随想录训练营】【Day15】第六章｜二叉树｜层序遍历｜226.翻转二叉树｜101.对称二叉树
士多啤梨先生の博客
02-15 2103
【代码随想录训练营】【Day15】第六章｜二叉树｜层序遍历｜226.翻转二叉树｜101.对称二叉树
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
weixin_47284299的博客
10-08 633
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
算法训练day15Leetcode102二叉树层序遍历226翻转二叉树101对称二叉树
dc爱傲雪和技术
01-15 1009
对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
算法训练Day20 | LeetCode654. 最大二叉树（构造二叉树应用）；617. 合并二叉树（操作两个二叉树）；700. 二叉搜索树中的搜索（BST特性）；98.验证二叉搜索树（BST的双指针
weixin_47284299的博客
10-13 670
算法训练Day20 | LeetCode654. 最大二叉树（构造二叉树应用）；617. 合并二叉树（操作两个二叉树）；700. 二叉搜索树中的搜索（BST特性）；98.验证二叉搜索树（BST的双指针
c++/go算法模板, 刷题记录
MARSHCW的博客
09-01 1849
◉ 一、数组 1184. 公交站间的距离 难度：简单 环形公交路线上有 n 个站，按次序从 0 到 n - 1 进行编号。我们已知每一对相邻公交站之间的距离，distance[i] 表示编号为 i 的车站和编号为 (i + 1) % n 的车站之间的距离。 环线上的公交车都可以按顺时针和逆时针的方向行驶。 返回乘客从出发点 start 到目的地 destination 之间的最短距离。 示例 1： 输入：distance = [1,2,3,4], start = 0, destination = 1 输出
服务器虚拟化
最新发布
Hellc007的博客
10-30 470
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 965
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 457
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1214
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
2301_79272475的博客
10-30 281
Java复习24（PTA)：多种排序的book类*
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值