代码随想录学习笔记（二叉树的层序遍历）

题目描述

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

示例

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

解题思路

【步骤一】

定义一个队列，若根节点不为空，则根节点入队。

【步骤二】

层序遍历，记录每一次层节点个数，节点出队时，将不空的左/右孩子入队，记录弹出元素。

【步骤三】

将每次循环弹出的元素，插入一个二维数组中

理论基础

队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历。

参考代码

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {   
        queue<TreeNode*> que;//定义一个存节点的队列
        if(root!=nullptr)
        que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            int n=que.size();//记录每层节点个数
            vector<int>ans;
            while(n--){
                ans.push_back(que.front()->val);//元素出队，存入数组
                if(que.front()->left!=nullptr){//左孩子不空则入队
                    que.push(que.front()->left);
                }
                if(que.front()->right!=nullptr){//右孩子不空则入队
                    que.push(que.front()->right);
                }
                que.pop();
            }
            result.push_back(ans);//每一层的数组存入二维数组
        }
    return result;
    }
};

层序遍历十题

Leetcode107.二叉树的层次遍历Ⅱ

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;//定义一个存节点的队列
        if(root!=nullptr)
        que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            int n=que.size();//记录每层节点个数
            vector<int>ans;
            while(n--){
                ans.push_back(que.front()->val);//元素出队，存入数组
                if(que.front()->left!=nullptr){//左孩子不空则入队
                    que.push(que.front()->left);
                }
                if(que.front()->right!=nullptr){//右孩子不空则入队
                    que.push(que.front()->right);
                }
                que.pop();
            }
            result.push_back(ans);//每一层的数组存入二维数组
        }
        reverse(result.begin(),result.end());//反转数组
    return result;
    }
};

 Leetcode199.二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        vector<int>result;
        while(!que.empty()){
            int n=que.size();
            int ans;
            while(n--){
                if(n==0)//每层最右侧元素为要输出的元素
                ans=que.front()->val;
                if(que.front()->left)
                que.push(que.front()->left);
                if(que.front()->right)
                que.push(que.front()->right);
                que.pop();
            }
            result.push_back(ans);
        }
        return result;
    }
};

Leetcode.637二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*>q;
        if(root!=nullptr)
        q.push(root);
        vector<double> result;
        while(!q.empty()){
            int n=q.size();
            double ave=n;//记录个数
            double sum=0;//记录总数
            while(n--){
                sum=sum+q.front()->val;
                if(q.front()->left)
                q.push(q.front()->left);
                if(q.front()->right)
                q.push(q.front()->right);
                q.pop();
            }
            result.push_back(sum/ave);
        }
        return result;
    }
};

Leetcode.429 N叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
       queue<Node*> que;//定义一个存节点的队列
        if(root!=nullptr)
        que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            int n=que.size();//记录每层节点个数
            vector<int>ans;
            while(n--){
                ans.push_back(que.front()->val);//元素出队，存入数组
                for(const auto&child:que.front()->children)//遍历元素的孩子
                que.push(child);
                que.pop();
            }
            result.push_back(ans);//每一层的数组存入二维数组
        }
    return result; 
    }
};

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

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;//定义一个存节点的队列
        if(root!=nullptr)
        que.push(root);
        vector<int>result;
        while(!que.empty()){
            int n=que.size();//记录每层节点个数
            int ans=INT_MIN;
            while(n--){
                ans=max(ans,que.front()->val);//记录最大值
                if(que.front()->left!=nullptr){//左孩子不空则入队
                    que.push(que.front()->left);
                }
                if(que.front()->right!=nullptr){//右孩子不空则入队
                    que.push(que.front()->right);
                }
                que.pop();
            }
            result.push_back(ans);//每一层的数组存入二维数组
        }
    return result;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;//定义一个存节点的队列
        if(root!=nullptr)
        que.push(root);
        while(!que.empty()){
            int n=que.size();//记录每层节点个数
            while(n--){
                if(n==0){//每层最后一个节点指向nullptr
                    que.front()->next=nullptr;
                }
                if(que.front()->left!=nullptr){//左孩子不空则入队
                    que.push(que.front()->left);
                }
                if(que.front()->right!=nullptr){//右孩子不空则入队
                    que.push(que.front()->right);
                }
                Node*cur=que.front();
                que.pop();
                if(n!=0)//如果节点不是每层最后一个节点，则指向队列的front（）元素
                cur->next=que.front();
            }
        }
    return root;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;//定义一个存节点的队列
        if(root!=nullptr)
        que.push(root);
        while(!que.empty()){
            int n=que.size();//记录每层节点个数
            while(n--){
                if(n==0){
                    que.front()->next=nullptr;
                }
                if(que.front()->left!=nullptr){//左孩子不空则入队
                    que.push(que.front()->left);
                }
                if(que.front()->right!=nullptr){//右孩子不空则入队
                    que.push(que.front()->right);
                }
                Node*cur=que.front();
                que.pop();
                if(n!=0)
                cur->next=que.front();
            }
        }
    return root;
    }
};

Leetcode104.二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*>q;
        if(root!=nullptr)
        q.push(root);
        int count=0;
        while(!q.empty()){
            int n=q.size();
            while(n--){
                if(n==0)
                count++;
                if(q.front()->left)
                q.push(q.front()->left);
                if(q.front()->right)
                q.push(q.front()->right);
                q.pop();
            }
        }
    return count;
    }
};

 Leetcode111.二叉树最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr)
        return 0;
        if(root->left==nullptr&&root->right==nullptr)
        return 1;
        int min_depth = INT_MAX;
        if(root->left!=nullptr)
        min_depth=min(min_depth,minDepth(root->left));
        if(root->right!=nullptr)
        min_depth=min(min_depth,minDepth(root->right));
        return min_depth+1;
    }
};

题目来源

102. 二叉树的层序遍历 - 力扣（LeetCode）

参考

代码随想录 (programmercarl.com)