代码随想录|二叉树的层序遍历

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

代码随想录|二叉树的层序遍历

文章目录

102.二叉树的层序遍历

【题目描述】
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

【思路】
（1）使用队列进行每层节点的遍历
（2）使用size变量记录所在层还剩多少节点
（3）将每层的非空左右孩子插入队列中

代码：

/**
 * 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>> result;
        queue<TreeNode*> que;
        if(root != nullptr){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            vector<int> temp;
            while(size--){
                TreeNode* node = que.front();
                temp.push_back(node->val);
                que.pop();
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(temp);
        }
        return result;
    }
};

时间复杂度：O(n),每个节点进队出队各一次
空间复杂度：O(n),队列中元素的个数不超过 n个

107.二叉树的层次遍历II

【题目描述】
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

【思路】
（1）将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>> result;
        queue<TreeNode*> que;
        if(root != nullptr){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            vector<int> temp;
            while(size--){
                TreeNode* node = que.front();
                temp.push_back(node->val);
                que.pop();
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(temp);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

199.二叉树的右视图

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

【思路】
（1）使用层序遍历
（2）根据题目意思，找到最右侧也就是找到每层的最后一个节点的值。
（3）将每层最后一个节点的值保存在result中

代码：

/**
 * 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> result;
        queue<TreeNode*> que;
        if(root != nullptr){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            TreeNode* node;
            while(size--){
                node = que.front();
                que.pop();
                if(node->left){
                    que.push(node->left);
                }if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(node->val);
        }
        return result;
    }
};

637.二叉树的层平均值

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

【思路】
（1）层序遍历的变法

代码：

/**
 * 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> result;
        queue<TreeNode*> que;
        if(root != nullptr){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            int sum = que.size();
            double temp = 0;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                temp += node->val;
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(temp/sum);
        }
        return result;
    }
};

429.N叉树的层序遍历

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

【思路】
（1）层序遍历的变法

代码

/*
// 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>> result;
        queue<Node*> que;
        if(root != nullptr){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            vector<int> temp;
            while(size--){
                Node* node = que.front();
                que.pop();
                temp.push_back(node->val);
                for(int i = 0;i < node->children.size(); ++i){
                    if(node->children[i]){
                        que.push(node->children[i]);
                    }
                }
            }
            result.push_back(temp);
        }
        return result;
    }
};

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

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

【思路】
（1）层序遍历的变法

代码：

/**
 * 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> result;
        queue<TreeNode*> que;
        if(root != nullptr){
            que.push(root);
        } 
        while(!que.empty()){
            int size = que.size();
            int max = INT_MIN;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->val > max){
                    max = node->val;
                }
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(max);
        }
        return result;
    }
};

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

【题目描述】
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

【思路】
（1）层序遍历的变法

代码：

/*
// 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*> que;
        if(root != nullptr){
            que.push(root);
        }

        while(!que.empty()){
            int size = que.size();
            while(size--){
                Node* node = que.front();
                que.pop();
                if(size == 0){
                    node->next = nullptr;
                }else if(size > 0){
                    node->next = que.front();
                }
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};

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

【题目描述】
给定一个二叉树：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

【思路】
（1）层序遍历的变法
（2）和116题写法一模一样

代码：

/*
// 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*> que;
        if(root != nullptr){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            while(size--){
                Node* node = que.front();
                que.pop();
                if(size == 0){
                    node->next = nullptr;
                }else if(size > 0){
                    node->next = que.front();
                }
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};

104.二叉树的最大深度

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

【思路】
（1）层序遍历的变法

代码：

/**
 * 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) {
        queue<TreeNode*> que;
        if(root != nullptr){
            que.push(root);
        }
        int high = 0;
        while(!que.empty()){
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
             high++;
        }
        return high;
    }
};

111.二叉树的最小深度

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

【思路】
（1）层序遍历的变法

代码：

/**
 * 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*> que;
        if(root != nullptr){
            que.push(root);
        }
        int high = 0;
        while(!que.empty()){
            int size = que.size();
            ++high;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(!node->left && !node->right){
                    return high;
                }
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
        }
        return high;
    }
};
weixin_51707660
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树层次遍历代码完整代码（C语言）
xiuhhhua的博客
08-06 7686
二叉树层次遍历思路就是使用队列进行存储，当出队一个元素，则将其左右子树入队。
【代码随想录】——二叉树层序遍历
m0_51660741的博客
06-10 320
之前介绍的是二叉树的深度优先遍历，接着是二叉树的另外一种遍历方式——层序遍历。层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。102. 二叉树的层序遍历方法一： 方法二：相较于方法一，不同之处在于：for循环将每层填好的path放进res中之后，用path.clear()清除每层的path，就不用每一层申请一个新path。 107. 二叉树的层序遍历 II该题与上题的
二叉树的层次遍历（C语言）
热门推荐
chenshengnanii的博客
05-24 2万+
一、二叉树的概念以及结构 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树组。 二、二叉树的遍历图解 先序遍历 中序遍历 后序遍历 层次遍历 ...
【C语言】二叉树的层序遍历
wzx0806的博客
07-30 2830
要对二叉树进行层序遍历，那么我们首先得先创建出来一个二叉树了。
数据结构-二叉树四种遍历方法（代码）
有朋自远方来，不亦乐乎。
08-26 3880
例图：以下的几种遍历均以此图为基准。
二叉树层序遍历-实现代码-队列
12-02
/* 设栈元素为二叉树的指针类型 */ typedef struct { QElemType *base; int front; /* 头指针,若队列不空,指向队列头元素 */ int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */ } SqQueue; ...
js代码-二叉树的层序遍历
07-16
js代码-二叉树的层序遍历
完全二叉树的层序遍历-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针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
数据结构-二叉树（包含二叉树的层次建树、前中后序遍历、层次遍历解析及代码）
mayu_xuan的博客
12-11 2238
树是n(n>=0)个结点的有限集。当n=0时，称为空树。在任意一棵非空树中应满足：1）有且仅有一个特定的结点称为根的结点。2）当n>1时，其余结点可以分为m(m>0)个互不相交的有限集T1,T2,......,Tm,其中每个集合本身又是一棵树，并且称为根的子树。二叉树是另一种树形结构。其特点是每个结点至多只有两棵子树（即二叉树中不存在度大于二的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。与树相似，二叉树也以递归的形式定义。
二叉树及其遍历方式+代码
weixin_50901244的博客
02-22 3476
二叉树及其遍历方式1、树型结构及基本概念1.1 树型结构概念1.2 一些重要概念2. 二叉树及基本概念2.1 二叉树概念2.2 两种特殊的二叉树2.3 二叉树的性质2.4 二叉树的存储2.5 二叉树的基本操作2.5.1 二叉树的遍历2.5.2 代码 1、树型结构及基本概念 1.1 树型结构概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树型结构的特点 子树不相交 除根节点外，每个节点有
二叉树的层序遍历
weixin_43744293的博客
06-24 1310
目录具体实现的代码1.树节点定义：2.层序遍历代码：实现区分不同层的节点方法1：使用一个队列方法2：使用两个队列完整的测试代码及测试结果 二叉树的层序遍历就是从根节点开始，一层一层的显示节点数据，每一层都是从左往右。如下图所示，层序遍历的结构就为：‘*’->‘-’->‘C’->‘+’->‘B’->‘E’->‘F’。 要想实现层序遍历，可以使用队列的数据结构。借用其先进先出的特点，每当访问到一个节点时，就将节点的数据打印并把左右子节点放入队列中。过程如下图 具体实现的代
二叉树的遍历算法（前中后+层次遍历）的递归和迭代写法
qq_43472612的博客
07-25 407
介绍了二叉树的4种遍历算法，每一种都用递归和迭代完成。
二叉树的层序遍历算法
api_variable811的博客
09-12 298
二叉树的层序遍历算法是一种按照层级顺序访问节点的方法，它利用队列的先进先出特性来实现。通过遍历每一层的节点，并将其子节点入队，我们可以按照层级顺序获取二叉树中的节点值。在这篇文章中，我们将介绍如何实现二叉树的层序遍历算法，并给出相应的源代码。在每一次迭代中，我们首先取出队首节点，访问它，并将它的左右子节点（如果存在）依次入队。如果该节点存在右子节点，则将右子节点入队。变量记录当前层的节点数量，这是为了在内层循环中准确地遍历当前层的节点。以上示例中，我们创建了一个二叉树，并使用层序遍历算法对其进行遍历。
二叉树的层序遍历（C语言实现）
qq_45519325的博客
07-25 7271
层序遍历(C语言实现),王道数据结构
c语言实现层次遍历二叉树完整代码
s10087的博客
07-09 2963
c语言实现层次遍历二叉树完整代码
Leetcode——二叉树的层次遍历
IT荻的博客
12-21 855
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 思路： 1.题目给出从左到右访问节点，自然想到的就是BFS，广度优先搜索。每个节点访问且仅访问一次。所以时间复杂度是O(N) 2.深...
代码实现层序遍历二叉树（C语言）
Prefectkn的博客
07-20 3130
本篇博客将介绍二叉树的层序遍历原理及代码实现。
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): ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值