【代码随想录】——二叉树层序遍历

已于 2022-06-18 17:02:18 修改
阅读量309 收藏
点赞数
文章标签： 数据结构 leetcode 广度优先
于 2022-06-10 15:39:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51660741/article/details/125180525
版权

之前介绍的是二叉树的深度优先遍历，接着是二叉树的另外一种遍历方式——层序遍历。

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

102. 二叉树的层序遍历

方法一：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if(root==NULL) return res;
        que.push(root);

        while(!que.empty()){
            int size=que.size();//变化的size，因为每次的que都在变化
            vector<int> path;//每完成一层for循环，重新定义一个新path，不用清除之前的数据，满足了[[3],[9,20]]这种要求
            //一次for循环，填充每一个path
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                path.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            } 
            //for循环之后，将填好的path放进res中
            res.push_back(path);
        }
        return res;
    }
};

方法二：相较于方法一，不同之处在于：for循环将每层填好的path放进res中之后，用path.clear()清除每层的path，就不用每一层申请一个新path。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<int> path;
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if(root==NULL) return res;
        que.push(root);

        while(!que.empty()){
            int size=que.size();//变化的size，因为每次的que都在变化
            //一次for循环，填充每一个path
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                path.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            } 
            res.push_back(path);//for循环之后，将每层填好的path放进res中
            path.clear();//清除每层的path
        }
        return res;
    }
};

107. 二叉树的层序遍历 II

该题与上题的不同之处在于：自底向上的层序遍历

其实只需要在上题的基础上，做一个reverse的操作即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<int> path;
        vector<vector<int>> res;
        queue<TreeNode*> q;
        if(root==NULL) return res;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                path.push_back(node->val);
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            res.push_back(path);
            path.clear();
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

199. 二叉树的右视图

该题也是层序遍历的变形。其实就是将每层的最后一个元素放进res中返回即可 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> path;
        vector<int> res;
        queue<TreeNode*> q;
        if(root==NULL) return res;
        q.push(root);

        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                path.push_back(node->val);
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            res.push_back(path[path.size()-1]);
        }
        return res;
    }
};

 637. 二叉树的层平均值

 在每一层for循环的时候将sum统计出来，然后在for循环结束之后就求平均值，将平均值放进res中。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*>q;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            double sum=0;
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                sum+=node->val;
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            res.push_back(sum/size);
        }
        return res;
    }
};

 429. N 叉树的层序遍历

和二叉树的层序遍历区别在于：二叉树只有两个孩子节点，判断左右孩子不为空即可让他们入队。而N叉树有n个孩子节点，就需要借助for循环将每一个孩子判空然后入队。

 for(int j=0;j<node->children.size();j++){//将node节点的孩子节点依次放进队列中
                    if(node->children[j]) q.push(node->children[j]);
                }
/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

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

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        vector<int> path;
        queue<Node*> q;
        if(root==NULL) return res;
        q.push(root);

        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                Node* node=q.front();
                q.pop();
                path.push_back(node->val);
                for(int j=0;j<node->children.size();j++){//将node节点的孩子节点依次放进队列中
                    if(node->children[j]) q.push(node->children[j]);
                }
            }
            res.push_back(path);
            path.clear();
        }
        return res;
    }
};

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

 层序遍历大框架，每层for循环的时候，比较求出最大值，每层for循环结束后，将最大值放进res。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> q;
        if(root==NULL) return res;
        q.push(root);

        while(!q.empty()){
            int size=q.size();
            int max=INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->val>max) max=node->val;
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            res.push_back(max);
        }
        return res;
    }
};

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

每层for循环，重新定义size，nodepre，node

在单层遍历时（包括i=0,i>0时）记录本层的头部节点，然后在遍历的时候（i>0时）让前一个节点指向本节点就可以了

然后每层for循环结束，本层最后一个节点指向NULL

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> q;
        if(root!=NULL) q.push(root);

        while(!q.empty()){
            //每层for循环，重新定义size，nodepre，node
            int size=q.size();
            Node* nodepre;
            Node* node;

            for(int i=0;i<size;i++){
                if(i==0){
                    nodepre=q.front();//取出每层的第一个节点
                    q.pop();
                    node=nodepre;
                }
                else{
                    node=q.front();
                    q.pop();
                    nodepre->next=node;//本层前一个节点指向本节点
                    nodepre=nodepre->next;
                } 
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            nodepre->next=NULL;//每层for循环结束，本层最后一个节点指向NULL
        }
        return root;
    }
};

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

这道题是二叉树，上一道题是完美二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

每层for循环，重新定义size，nodepre，node

在单层遍历时（包括i=0,i>0时）记录本层的头部节点，然后在遍历的时候（i>0时）让前一个节点指向本节点就可以了

然后每层for循环结束，本层最后一个节点指向NULL

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> q;
        if(root!=NULL) q.push(root);

        while(!q.empty()){
            int size=q.size();
            Node* nodePre;
            Node* node;
            for(int i=0;i<size;i++){
                if(i==0){
                    nodePre=q.front();
                    q.pop();
                    node=nodePre;
                }
                else{
                    node=q.front();
                    q.pop();
                    nodePre->next=node;
                    nodePre=nodePre->next;
                }
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            nodePre->next=NULL;
        }
        return root;
    }
};

 104. 二叉树的最大深度

最大深度即是二叉树的层数，层序遍历获得层数即可。

利用层序遍历的大框架，每层for循环结束之后sum++

最终while结束后，返回sum 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        int sum=0;
        queue<TreeNode*> q;
        if(root!=NULL) q.push(root);
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            sum++;
        }
        return sum;

    }
};

111. 二叉树的最小深度

层序遍历大框架，当node的左右孩子均为空的时候，说明到了最低点的一层，直接返回深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> q;
        int mindepth=0;
        if(root!=NULL) q.push(root);
        while(!q.empty()){
            int size=q.size();
            mindepth++;
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                if(node->left==NULL && node->right==NULL) return mindepth;//当左右节点都为空，说明到了最低点的一层，直接返回
            }
        }
        return mindepth;
    }
};

513. 找树左下角的值

层序遍历（队列） 

 //记录每一行的第一个元素即可，不断更新这个res就可以记录到最后一行的第一个元素

（定义了两个vector，将每一行的元素都放进去，最后返回vector的vector。这个办法就有点笨拙：return resback[resback.size()-1][0];）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> q;
        int res=0;
        if(root!=NULL) q.push(root);
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(i==0) res=node->val;//记录每一行的第一个元素即可，不断更新res就可以记录到最后一行的第一个元素
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
        }
        return res;
    }
};

ChengZiJo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
js代码-二叉树的层序遍历
07-16
js代码-二叉树的层序遍历
二叉树的层序遍历 + 通过层序遍历实现二叉树的操作
AwwzJ_0821的博客
01-04 594
使用是将TreeNode 替换成 TreeNodeWithLevel，并且向队列中添加元素时，传入结点的同时，传入 level 层数即可。使用两个队列，一个队列存放结点，另一个队列存放相应的层数。需要注意的是两个队列对应的元素个数一样，所以在 while() 条件判断时，取任意一个队列的元素不为空即可。取出一个元素，就把其相应的左右孩子放入队列中（null 的不用放入）。使用带层数的层序遍历，当从队列中取出的元素的 level == k 时，size++。层序遍历，利用队列，每取出一个元素，size++
LeetCode #100 相同的树——每日一题
JUST CODE IT
05-08 165
100. 相同的树 给你两棵二叉树的根节点p和q，编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 示例 1： 输入：p = [1,2,3], q = [1,2,3] 输出：true 示例 2： 输入：p = [1,2], q = [1,null,2] 输出：false 示例 3： 输入：p = [1,2,1], q = [1,1,2] 输出：false 提示： 两棵树上的节点数目都在范围...
二叉树遍历——层序遍历
热门推荐
m0_67198282的博客
03-24 1万+
目录 1.什么是层序遍历？ 2.实现思路 3.代码实现 1.什么是层序遍历？ 就是将一颗树按照每一层每一层的方式进行遍历 例如这棵树，进行层序遍历的结果应该是 那么我们该怎样去实现呢？ 2.实现思路 利用队列先进先出的思想去实现 重要思想：一层带一层 我们先把书的根节点入进去，然后每出一次都把它的子节点入队，出子节点时也一样 3.代码实现 因为我们用的是c来实现，所以在实现前请准备好一个队列 队列头文件 #pragma once #incl.
二叉树的深度优先遍历（递归法）
Aaron_Yang
07-13 495
二叉树的结构体定义： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode *left, Tree
【LeetCode】-- 144. 二叉树的前序遍历
局部变量和全局变量
08-14 475
给你二叉树的根节点root，返回它节点值的前序遍历。
二叉树层次遍历代码完整代码（C语言）
xiuhhhua的博客
08-06 7542
二叉树层次遍历思路就是使用队列进行存储，当出队一个元素，则将其左右子树入队。
leetcode：889. 根据前序和后序遍历构造二叉树
OceanStar的博客
11-22 3546
题目来源 889. 根据前序和后序遍历构造二叉树 题目描述 题目解析 我们知道，在前序遍历的时候，根节点是第一个输出，而在后序遍历中，根节点是最后一个输出； 那么我们可以利用前序遍历来构建Tree，然后通过后续遍历来检验当前树是否构建完毕。 首先我们创建一个节点作为 root，root = TreeNode(pre[preIndex])当 root.val == post[posIndex]时, 意味着我们已经构建完毕了当前子树，如果当前子树没有构建完毕，那么我们就递归的构建左右子树。 具体代码: /**
【C语言】二叉树的层序遍历
wzx0806的博客
07-30 2621
要对二叉树进行层序遍历，那么我们首先得先创建出来一个二叉树了。
二叉树层序遍历-实现代码-队列
12-02
/* 设栈元素为二叉树的指针类型 */ typedef struct { QElemType *base; int front; /* 头指针,若队列不空,指向队列头元素 */ int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */ } SqQueue; ...
完全二叉树的层序遍历-labview
12-20
完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全二叉树的层序遍历-labview完全...
基于Java的二叉树层序遍历打印实现.docx
06-27
二叉树层序遍历Ⅰ——剑指offer32-Ⅰ 从上到下，从左到右打印二叉树，返回一维数组int[] res。 class Solution { public int[] levelOrder(TreeNode root) { if (root == null) return new int[0]; Queue...
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
【算法小白周赛1E】ET表题解与代码（算法与数据结构刷题计划）
qq_29495615的博客
05-01 758
其实所谓的ET表操作，其实就是对数组的某一长度的前、后缀进行区间减去某个数的操作，此时我们应该想到非常擅长进行区间操作的好东西——差分。StarryCoding - 编程开发新手村，非常适合新手小白的一个网站，推荐给大家~不会有任何影响，所以对它的操作可以忽略，而我们的最终目的——将数组。，现在需要判断能否通过ET表的这两种操作将这个数组的每一个数都变成。的进行一次操作，最后特判一下进行了上述操作后。为了测试ET表的性能，小e找来了一个长度为。的修改就等效于对差分数组的。，以及最少的操作次数。
【数据结构】第二章 线性数据结构.概念性补充
KX_52517的博客
05-01 830
本文是对【数据结构】线性数据结构的补充，若没有疑惑可跳过本文。
【数据结构】链表专题2
m0_74091744的博客
05-01 1191
前言本篇博客继续探讨有关链表的专题，这片博客的题，提前打个预防针，有点意思哦，哈哈哈，话不多说，进入正文若有问题 评论区见📝。
线性数据结构-手写队列-Queue
最新发布
CSDN_LiMingfly的博客
05-03 827
将元素添加到队列后的操作称为入队，从队列中移除元素的操作称为出队。但剩余接下里的步骤才是复杂的，因为需要在根元素迁移走后，寻找另外的最小元素迁移到对头。延迟队列的实现，主要为在优先队列的基础上，添加可重入锁 ReentrantLock 对阻塞队列的实现。首先将元素2挂到队列尾部，之后通过 (k - 1) >>> 1 计算父节点位置，与对应元素进行比对和判断交换。在存放元素时，以遵循它的特点，会在存存放过程中，通过队尾元素向上比对迁移。1：单端队列和双端队列，分别对应的实现类是哪个？
代码随想录-二叉树（节点）
希希雾里
04-28 885
代码随想录-二叉树（节点）
数据结构中的算法
zy1215058242的博客
05-01 933
什么是算法呢？算法是描述解决问题的方法。算法(Algorithm)这个单词最早出现在波斯数学家阿勒·花刺子密在公园825年(相当于我们中国的唐朝时期)所写的《印度数字算数》中。如今普遍认可的对算法的定义是：算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。现实世界中的问题千奇百怪，算法当然也就千变万化，没有通用的算法可以解决所有问题。甚至解决一个小问题，很优秀的算法却不一定适合它。指令能被人或机器等计算装置执行。
python二叉树层序遍历代码
03-17
当然可以！下面是一个Python的二叉树层序遍历的代码示例： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def levelOrder(root): if not root: return [] result = [] queue = [root] while queue: level = [] size = len(queue) for _ in range(size): node = queue.pop(0) level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) result.append(level) return result ``` 这段代码定义了一个`TreeNode`类来表示二叉树的节点，其中包含了节点的值、左子节点和右子节点。`levelOrder`函数实现了二叉树的层序遍历，它使用了一个队列来辅助遍历过程。首先将根节点加入队列，然后在每一层遍历时，将当前层的节点值添加到结果列表中，并将下一层的节点加入队列。最后返回结果列表即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值