day15|各种遍历的应用

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量999 收藏 7
点赞数 18
文章标签： java 算法 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39522022/article/details/139178809
版权

相关题目：
层次遍历会一打十
反转二叉树
对称二叉树

层次遍历会一打十

自底向上的层序遍历

在这里插入图片描述
实现思路：层次遍历二叉树，将遍历后的结果revers即可

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> que = new ArrayDeque<>();
        if (root == null) {
            return res;
        }
        que.offer(root);
        int size = 0;
        while (!que.isEmpty()) {
            size = que.size();
            List<Integer> list = new ArrayList<>();
            while (size > 0) {
                TreeNode cur = que.poll();
                list.add(cur.val);
                if (cur.left != null) {
                    que.offer(cur.left);
                }
                if (cur.right != null) {
                    que.offer(cur.right);
                }

                size--;
            }
            res.add(list);
        }
        Collections.reverse(res);
        return res;
    }

输出二叉树的右视图节点

在这里插入图片描述
实现思路：层次遍历二叉树，记录二叉树每一层的节点数，到达该层最后一个节点时，将其加入到结果集即可

public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new ArrayDeque<>();
        que.offer(root);
        int size = 0;
        while(!que.isEmpty()){
            size = que.size();
            while(size>0){
                TreeNode cur = que.poll();
                //遍历到该层最后一个节点
                if(size == 1){
                    res.add(cur.val);
                }
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
                size--;
            }
        }
        return res;
    }

二叉树每层的平均值

在这里插入图片描述
实现思路：层次遍历二叉树，计算每一层的平均值，注意：每层数之和及平均值的数据类型

public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        Queue<TreeNode> que = new ArrayDeque<>();
        if(root == null){
            return res;
        }
        int size = 0;
        que.offer(root);
        while(!que.isEmpty()){
            size = que.size();
            double sum = 0;
            for (int i = 0; i < size; i++) {
                TreeNode cur = que.poll();
                sum += cur.val;
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
            }
            res.add(sum/size);
        }
        return res;
    }

N叉树的·层次遍历

在这里插入图片描述

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;
    }
};

public class LevelOrderNode {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<Node> que = new ArrayDeque<>();
        que.offer(root);
        while (!que.isEmpty()) {
            int size = que.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                Node cur = que.poll();
                list.add(cur.val);
                List<Node> children = cur.children;
                if (children == null || children.size() == 0) {
                    continue;
                }
                for (Node child : children) {
                    if (child != null) {
                        que.offer(child);
                    }
                }
            }
            res.add(list);
        }
        return res;
    }

}

在二叉树的每一行中找最大值

在这里插入图片描述
实现思路：层次遍历二叉树，记录每一层的最大值

public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que = new ArrayDeque<>();
        int size = 0;
        que.offer(root);
        while(!que.isEmpty()){
            size = que.size();
            int max = Integer.MIN_VALUE;
            while(size>0) {
                TreeNode cur = que.poll();
                max = Math.max(max,cur.val);
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
                size--;
            }
            res.add(max);
        }
        return res;
    }

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

在这里插入图片描述
实现思路：层次遍历二叉树，记录每层元素个数，遍历每层元素，元素个数大于1时，使其next指针指向队头元素；元素个数为1时，使其next指针指向null即可

class NodeText {
    public int val;
    public NodeText left;
    public NodeText right;
    public NodeText next;

    public NodeText() {}

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

    public NodeText(int _val, NodeText _left, NodeText _right, NodeText _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
public class Connect {
    public NodeText connect(NodeText root) {
        Queue<NodeText> que = new ArrayDeque<>();
        if(root == null){
            return root;
        }
        que.offer(root);
        while(!que.isEmpty()){
            int size = que.size();
            while(size>0){
                NodeText cur = que.poll();
                if(size>1){
                    NodeText temp = que.peek();
                    cur.next = temp;
                }
                else{
                    cur.next =null;
                }
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
                size--;
            }
        }
        return root;
    }
}

求二叉树的最大深度

在这里插入图片描述
实现思路：层次遍历二叉树，记录树的层数

public int maxDepth(TreeNode root) {
        int maxDepth = 0;
        int size = 0;
        if(root == null){
            return 0;
        }
        Queue<TreeNode> que = new ArrayDeque<>();
        que.offer(root);
        while(!que.isEmpty()){
            maxDepth++;
            size = que.size();
            while(size>0){
                TreeNode cur = que.poll();
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
                size--;
            }
        }
        return maxDepth;
    }

求二叉树的最小深度

在这里插入图片描述

实现思路：层次遍历二叉树，当某个节点的左右孩子均为null时，输出该节点所在层数，及就是树的最小深度

public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int deep = 0;
        int size = 0;
        Queue<TreeNode> que = new ArrayDeque<>();
        que.offer(root);
        while (!que.isEmpty()) {
            deep++;
            size = que.size();
            while (size > 0) {
                TreeNode cur = que.poll();
                if (cur.left == null && cur.right == null) {
                    return deep;
                } else {
                    if (cur.left != null) {
                        que.offer(cur.left);
                    }
                    if (cur.right != null) {
                        que.offer(cur.right);
                    }
                }
                size--;
            }
        }
        return deep;
    }

反转二叉树（掌握递归遍历）

实现方法：使用前序遍历、后序遍历及其层次遍历均可实现
前序遍历实现方法：遍历中间节点，中间节点的左右孩子交换位置即可
后序遍历实现方法：遍历的左子树和右子树，交换中间节点左右孩子交换位置即可
层次遍历：遍历每一层的各个节点，反转各个节点的左右孩子即可

public class InvertTree extends TreeNode {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
//        //前序
//        swap(root);
//        invertTree(root.left);
//        invertTree(root.right);

//        //后序
//        invertTree(root.left);
//        invertTree(root.right);
//        swap(root);
        //层次遍历--迭代
        Queue<TreeNode> que = new ArrayDeque<>();
        int size = 0;
        que.offer(root);
        while(!que.isEmpty()){
            size = que.size();
            while(size>0){
                TreeNode cur = que.poll();
                swap(cur);
                if(cur.left!=null){
                    que.offer(cur.left);
                }
                if(cur.right!=null){
                    que.offer(cur.right);
                }
                size--;
            }
        }

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

对称二叉树

递归实现：
递归三部曲

  1. 确定递归函数的参数和返回值
    因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。
    返回值自然是bool类型。
    代码如下：
    bool compare(TreeNode* left, TreeNode* right)
  2. 确定终止条件
    要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。
    节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）
  • 左节点为空，右节点不为空，不对称，return false
  • 左不为空，右为空，不对称 return false
  • 左右都为空，对称，返回true
  • 左右都不为空，比较节点数值，不相同就return false
    代码如下：
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

注意上面最后一种情况，我没有使用else，而是else if， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。
3. 确定单层递归的逻辑
此时才进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

  • 比较二叉树外侧是否对称 ：传入的是左节点的左孩子，右节点的右孩子。
  • 比较内侧是否对称：传入左节点的右孩子，右节点的左孩子。

如果左右都对称就返回true ，有一侧不对称就返回false 。
实现过程：

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;
        else if (left != null && right == null) return false;
        else if (left != null && right != null && left.val != right.val) return false;
        else if (left == null && right == null) return true;
        boolean inside = compare(left.left, right.right);
        boolean outside = compare(left.right, right.left);
        return inside && outside;
    }
}
【1day】金蝶OA系统server_file 目录遍历漏洞学习
记录并分享学习安全的知识点..
05-02 3272
警告 请勿使用本文提到的内容违反法律。 本文不提供任何担保 目录 警告 一、概述 二、影响版本 三、漏洞复现 验证poc如下： 一、概述 金蝶OA server_file 存在目录遍历漏洞，攻击者通过目录遍历可以获取服务器敏感信息。 二、影响版本 金蝶OA产品，影响版本不详 三、漏洞复现 验证poc如下： Windows服务器 appmonitor/protected/selector/server_file/files?folder=C://&...
代码随想录训练营Day13 | 二叉树理论基础 | 递归遍历 | 迭代遍历 | 统一迭代 | 层序遍历
m0_68965961的博客
09-23 502
int val;二叉树的定义 和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。
代码随想录 day15| 层序遍历
qq_65208982的博客
05-01 188
层序遍历一个二叉树，就是从左到右一层层去遍历二叉树，和之前的都不一样。需要借用一个辅助数据结构即队列实现，队列先进后出，符合一层层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。然而 这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
代码随想录day15｜层序遍历10道｜226.翻转二叉树｜101. 对称二叉树
weixin_42161901的博客
10-06 809
笔记
代码随想录算法day11 | 二叉树part01 | 递归遍历 ， 迭代遍历，统一迭代，层序遍历
m0_62415132的博客
08-05 1202
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;大家会发现二叉树的定义 和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。这里要提醒大家要注意二叉树节点定义的书写方式。在现场面试的时候 面试官可能要求手写代码，所以数据结构的定义以及简单逻辑的代码一定要锻炼白纸写出来。二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。
day15 | 层序遍历、 226.翻转二叉树、101. 对称二叉树
weixin_45048521的博客
08-16 127
写递归的时候，注意三部曲：1、确定递归函数的参数和返回值2、确定终止条件3、确定单层递归的逻辑。
day14/day15 二叉树前中后序遍历 | 层序遍历
mest_gg的博客
10-30 108
这里帮助大家确定下来递归算法的三个要素。
零基础代码随想录【Day15】|| 层序遍历 ，226.翻转二叉树，101. 对称二叉树
Andrew______的博客
01-29 427
层序遍历一个二叉树。这种遍历的方式和我们之前讲过的都不太一样。本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。这道题目一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。101. 对称二叉树 （优先掌握递归）226.翻转二叉树 （优先掌握递归）先看视频讲解，会更容易一些。
代码随想录算法训练营day15| 层序遍历、226. 翻转二叉树、101. 对称二叉树
zwq54argfun的博客
01-25 412
层序遍历是图论中的广度优先搜索在二叉树中的应用，使用队列这种数据结构实现，一共十道题，大同小异，因此只贴这一道题的代码。该题解法和100.相同的树、101.对称二叉树解法类似。迭代法同时迭代左右子树。572、另一棵树的子树。
代码随想录算法训练营Day15|二叉树Part02|层序遍历||226翻转二叉树||101对称二叉树
luyimin87的博客
04-07 998
层序遍历看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。226.翻转二叉树 （优先掌握递归）这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。101. 对称二叉树 （优先掌握递归）先看视频讲解，会更容易一些。
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
weixin_47284299的博客
10-08 644
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
Shell脚本遍历一个日期范围实例
09-15
在IT领域，Shell脚本是一种常用的自动化工具，尤其在Linux或Unix系统中，它能帮助我们执行一系列命令，包括处理文件、系统管理以及各种复杂的任务。在这个实例中，我们将探讨如何使用Shell脚本来遍历一个特定的日期...
php两个多维数组组合遍历的实例
10-19
在实际应用中，`searchloan()`方法可能是从数据库中获取贷款记录的查询，而`getLastDay()`方法可能是获取特定贷款的最后一天信息。 总结来说，这个实例展示了如何使用`foreach`循环遍历并处理多维数组，以及如何在...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 251
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Servlet的生命周期
最新发布
wyk的博客
11-13 840
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
1112--接口
kequanrrr的博客
11-12 367
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 669
Rest请求处理
JAVA学习接口案例实例
shangan_3的博客
11-08 236
【代码】JAVA学习接口案例实例。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 858
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
jQuery高级教程：动画、遍历与功能应用
在"day02-jquery高级.pdf"的学习材料中，本章主要聚焦于jQuery高级应用，包括动画效果、遍历方法、事件处理、插件机制以及表单校验。以下是详细的知识点概述： 1. **jQuery动画**： - **show()** 方法：用于显示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值