算法刷题｜二叉树的层序遍历、226.翻转二叉树、101.对称二叉树

最新推荐文章于 2024-07-25 13:44:24 发布
最新推荐文章于 2024-07-25 13:44:24 发布
阅读量36 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54352440/article/details/129546816
版权

二叉树层序遍历

层序遍历

题目：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

思路：使用一个size记录每一层的数量，然后进行输出

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();// 记录每一层有多少个元素
            List<Integer> ans = new LinkedList<>();
            while(size --> 0){
                TreeNode node = deque.pollFirst();
                ans.add(node.val);
                if(node.left != null){// 将左孩子入队
                    deque.addLast(node.left);
                }
                if(node.right != null){// 将右孩子入队
                    deque.addLast(node.right);
                }
            }
            res.add(ans);
        }
        return res;
    }
}

层序遍历||

题目：给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

方法一

直接在上面代码return之前反转一下list即可：Collections.reverse(res);

方法二
在插入结果集合的时候始终往第一个位置插入即可

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
            List<List<Integer>> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();// 记录每一层有多少个元素
            List<Integer> ans = new LinkedList<>();
            while(size --> 0){
                TreeNode node = deque.pollFirst();
                ans.add(node.val);
                if(node.left != null){// 将左孩子入队
                    deque.addLast(node.left);
                }
                if(node.right != null){// 将右孩子入队
                    deque.addLast(node.right);
                }
            }
            res.add(0,ans);// 这里始终插入在0位置，最后就实现了从底层开始输出的效果
        }
        return res;
    }
}

二叉树的右视图

题目：给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

思路：还是层序遍历，就是在每一次的最右一个元素就是最右侧的元素

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();// 还是需要记录一下每一层的大小，最后一个就是最右侧的元素
            for(int i = 0;i<size;i++){
                TreeNode node = deque.pollFirst();
                if(i == size - 1){// 最后一个就是最右侧的元素
                    res.add(node.val);
                }
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }               
            }  
        }
        return res;
    }
}

二叉树的层平均值

题目：给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

思路：层序遍历，然后每层统计一下平均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            double sum = 0d;
            int size = deque.size();
            for(int i = 0;i<size;i++){
                TreeNode node = deque.pollFirst();
                sum+=node.val;
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
            res.add(sum/size);
        }
        return res;
    }
}

N叉树的层序遍历

题目：给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

思路：使用队列存放元素，二叉树是在出队的时候将其左右孩子入队，这里就是将其所有孩子节点入队

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<Node> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            List<Integer> ans = new LinkedList<>();
            int size = deque.size();
            while(size --> 0){
                Node node = deque.pollFirst();
                ans.add(node.val);
                if(node.children != null){
                    for(Node n : node.children){
                        deque.addLast(n);
                    }
                }
            }
            res.add(ans);
        }
        return res;
    }
}

在每个树行中找到最大值

题目：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

思路：依旧是层序遍历，在每一行中找最大值

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            int max = Integer.MIN_VALUE;
            while(size --> 0){
                TreeNode node = deque.pollFirst();
                max = Math.max(max,node.val);
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
            res.add(max);
        }
        return res;
    }
}

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

题目：给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点

思路：层序遍历，将每一层的前n-1个元素连接起来，最后一个元素指向null

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return root;
        }
        Deque<Node> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            for(int i = 0;i<size;i++){
                Node node = deque.pollFirst();
                if(i < size - 1){// 只连接每一层的，这个判断防止当前层的最后一个元素连接到下一层的第一个元素了
                    node.next = deque.peek();
                }
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
        }
        return root;
    }
}

填充每个节点的下一个右节点指针||

题目：填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。
初始状态下，所有 next 指针都被设置为 NULL 。

同上

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return null;
        }
        Deque<Node> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            for(int i = 0;i<size;i++){
                Node node = deque.pollFirst();
                if(i < size - 1){
                    node.next = deque.peek();
                }
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
        }
        return root;
    }
}

二叉树的最大深度

题目：给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点

思路：层序遍历，每一层统计高度

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        int depth = 0;
        while(!deque.isEmpty()){
            int size = deque.size();
            while(size --> 0){
                TreeNode node = deque.pollFirst();
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

二叉树的最小深度

题目：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

思路：层序遍历，遇到了左右孩子都为null的时候，说明遇到了叶子节点，可以返回深度了

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        int depth = 1;// 因为根节点不为空，所有从1开始
        while(!deque.isEmpty()){
            int size = deque.size();
            while(size --> 0){
                TreeNode node = deque.pollFirst();
                if(node.left == null && node.right == null){// 遇到了叶子节点
                    return depth;
                }
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

翻转二叉树

题目：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

递归

思路：使用递归的方式，然后采用前序或者后序遍历进行交换节点

前序遍历

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

后序遍历

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

中序遍历

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        invertTree(root.left);
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        invertTree(root.left);// 中序遍历的话，这里就不能是右子树了，因为当前的右子树是反转前的左子树（已经被交换过了），当前的左子树是反转前的右子树（还没有反转的节点）
        return root;
    }
}

迭代

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            while(size --> 0){
                TreeNode node = deque.pollFirst();
                TreeNode temp = node.left;
                node.left = node.right;
                node.right = temp;
                if(node.left != null){
                    deque.addLast(node.left);
                }
                if(node.right != null){
                    deque.addLast(node.right);
                }
            }
        }
        return root;
    }
}

对称二叉树

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

递归

思路：采用后序遍历，判断左右孩子是否相等

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return true;
        }
        return compare(root.left,root.right);
    }
    private boolean compare(TreeNode left,TreeNode right){
        if(left != null && right == null){
            return false;
        }else if(left == null && right != null){
            return false;
        }else if(left == null && right == null){
            return true;
        }else if(left.val != right.val){
            return false;
        }else{// 左右两个节点的值相等，就往下继续遍历
        	// 左  右
            boolean outSide = compare(left.left,right.right);// 判断外侧是否相等
            // 右 左
            boolean inSide = compare(left.right,right.left);//判断内侧是否相等
            // 中
            return outSide && inSide;
        }
    }
}

迭代

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return true;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.addLast(root.left);
        deque.addLast(root.right);
        while(!deque.isEmpty()){
            TreeNode l = deque.pollFirst();
            TreeNode r = deque.pollFirst();
            if(l == null && r == null){
                continue;// 此处不能返回true，因为虽然当前节点相同，但是可能后面的左右子树存在不是对称的
            }
            if(l != null && r == null){
                return false;
            }
            if(l == null && r != null){
                return false;
            }
            if(l.val != r.val){
                return false;
            }
            deque.addLast(l.left);
            deque.addLast(r.right);

            deque.addLast(l.right);
            deque.addLast(r.left);
        }
        return true;
    }
}
lchao2048
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
20230622 | 102. 二叉树的层序遍历、226. 翻转二叉树、101.对称二叉树
qq_45885369的博客
06-22 83
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]
代码随想录算法训练营第十五天[二刷]|102.二叉树的层序遍历.226.翻转二叉树.101. 对称二叉树
MRmaand12的博客
12-11 219
代码随想录算法训练营第十五天
Day 15 层序遍历 226.翻转二叉树 101.对称二叉树
qq_46025584的博客
04-03 1618
所以nodePre完成对第一个层内节点的存储以后，再次进入for循环的时候nodePre存储的就是第一个层内节点，这样就能够实现左右节点相链接从而达到题目要求。以例子为例的话第二次for循环处理以后，第一次得到的node是元素值为2的节点，那这个节点的前一个节点是什么？//左子树：左 右子树：右。​ 处理逻辑：swap(root->left,root->right)//此处root指的是遍历的每一个节点，不是根节点。​ 和之前不一样的是，这里的头节点需要特殊处理，提前取出来，其他所有的节点处理方式一样；
算法D15 | 二叉树2 | 102. 层序遍历 226.翻转二叉树 101. 对称二叉树
memolaner的博客
02-07 1998
这个题依然可以用前中后序遍历（递归法，利用栈实现迭代法）或者利用队列来实现层次遍历解决。递归法的前序遍历是最直接简单的。队列里放的是Treenode的指针，这样才可以在遍历的时候仍然能够记录原来树的关系。这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。如果内层函数只是传入参数不同，打包成一个新的函数似乎也更好一些，简化了内部逻辑。看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。有10道题目都是同一个模板的问题，可以练习。
python-leetcode面试题解之第101题对称二叉树-题解.zip
04-29
本压缩包文件“python-leetcode面试题解之第101题对称二叉树-题解.zip”专注于解决LeetCode上的第101题——对称二叉树。这道题目在Python编程语言下的解决方案是核心内容，对于准备Python相关职位面试的求职者来说...
js代码-(算法)（二叉树）对称二叉树判断
07-15
同时，通过对称二叉树的判断，可以延伸出许多其他相关问题，如对称路径查找、对称翻转等，这些都是深化二叉树操作技能的重要练习。 在压缩包文件`main.js`中，可能包含了上述两种方法的实现代码，通过阅读和理解...
python-leetcode面试题解之对称二叉树.zip
03-06
本压缩包文件"python-leetcode面试题解之对称二叉树.zip"显然是针对Python程序员，特别是那些准备面试的人，重点讲解了如何解决LeetCode上的“对称二叉树”问题。 对称二叉树是二叉树的一种特殊形态，它的左右子树...
python-leetcode面试题解之第156题上下翻转二叉树-题解.zip
05-14
本篇文章将详细解析LeetCode面试题中的第156题——上下翻转二叉树。 题目描述： 这道题目要求我们实现一个函数，该函数接收一个二叉树的根节点，并对其进行上下翻转的操作。这里的上下翻转意味着原树的每个节点的左...
算法-KMP字符串匹配
xx_xb的博客
07-23 185
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 673
AtCoder Beginner Contest 363 ABCDE
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 236
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 826
二叉搜索树向左或向右指明方向，不用遍历整个树。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 538
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 692
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
danaaaa的博客
07-21 922
求众数方法
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
最新发布
m0_55763458的博客
07-25 462
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
三维点云中常用的表面重建算法
Argulo的博客
07-22 1240
表面重建算法起源于计算机视觉和计算几何学领域。早期的研究集中在从二维图像中提取三维信息。然而，随着三维扫描技术的进步，越来越多的研究转向了如何从点云数据中重建表面。三维点云表面重建技术的发展，始于20世纪90年代，主要推动力是激光扫描和结构光扫描的广泛应用。
DP 整数拆分&不同的二叉搜索树 DAY21
小木公的博客
07-25 630
没完全消化，特别是递推公式…我觉得是,另外还需要取最大值如何理解？//为什么是n + 1?//初始化dp[2] = 1;i <= n;j++){这道题想到用动规的方法来解决，就不太好想，需要举例，画图，分析，才能找到递推的关系。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被...综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值