二叉树和N叉树的广度优先遍历（C++)

原创已于 2025-04-10 10:24:11 修改 · 1.1k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#宽度优先 #c++ #算法

于 2022-02-22 21:49:04 首次发布

本文详细介绍了二叉树的层序遍历及其变体，包括层平均值、锯齿形遍历、最小深度和最大深度。同时，也探讨了N叉树的层序遍历问题，通过广度优先搜索策略解决各种遍历需求。这些算法在实际编程中有着广泛的应用。

前言

本文总结了通过广度优先遍历实现二叉树的相关问题。

一、二叉树的遍历

1.1 二叉树的层序遍历I

题目描述：给定二叉树的根节点 root ，返回其节点值的层序遍历，即逐层地从左到右访问所有节点。
题目分析：二叉树的层序遍历要求逐层访问节点，该过程可借助队列来实现。该队列保存每一层的节点值，队列的长度为该层的节点数。当在队列中遍历该层节点时时，将节点的下一层入队列。算法流程如下：

1、根节点入队；
2、while(队列不为空){
	  计算队列长度n；
	  定义新的节点node;
	  for(int i=0;i<n;i++){
	      从队列中取出节点；
	      处理该节点；
	      将该节点的左右孩子入队；
	  }
    }

其实现代码如下：

/**
 * 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) {
        if(root==nullptr) 
        return {};  //如果根节点不存在，返回空值
        vector<vector<int>> res;  //定义结果向量
        queue<TreeNode*> que;  //定义队列
        que.push(root);  //根节点入队
        while(!que.empty()){  //当队列不为空，即该层有节点时
            int n=que.size();  //计算该层节点数
            TreeNode* node;  //定义节点，作为队列中树节点与整型向量之间的桥梁
            vector<int> tmp;  //定义整型向量，用来存储该层所有节点的值
            for(int i=0;i<n;i++){
                node=que.front();  //取出节点
                que.pop();
                tmp.push_back(node->val);  //将节点值放入向量中
                if(node->left) que.push(node->left);  //如果该节点存在左孩子，则将它的左孩子入队
                if(node->right) que.push(node->right);  //如果该节点存在右孩子，则将它的右孩子入队
            }
            res.push_back(tmp);  //将每层的节点值加入最终的结果向量中
        }
        return res;
    }
};

1.2 二叉树的层序遍历II

题目描述：给定二叉树的根节点root ，返回其节点值自底向上的层序遍历，即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历。
题目分析：该题与上一题的不同之处在于返回值是自低向上的遍历，而上一题的返回值是自顶向下的遍历。因此，在上一题的基础上对返回值进行反转，或者将每一层的遍历结果进行头插即可。

/**
 * 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) {
        if(root==nullptr)
        return {};
        vector<vector<int>> res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int n=que.size();
            vector<int> tmp;
            TreeNode* node;
            for(int i=0;i<n;i++){
                node=que.front();
                que.pop();
                tmp.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(tmp);
        }
        reverse(res.begin(),res.end());  //向量反转
        //res.insert(res.begin(),tmp);  //向量头插
        return res;
    }
};

1.3 二叉树的层平均值

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

/**
 * 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) {
        if(root==nullptr)
        return {};
        vector<double> res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int n=que.size();
            TreeNode* node;
            double levSum=0;  //该值为每层节点值的和
            for(int i=0;i<n;i++){
                node=que.front();
                que.pop();
                levSum+=node->val;
                if(node->left) que.push(node->left);
                if(node->right)  que.push(node->right);
            }
            res.push_back(levSum/n);
        }
        return res;
    }
};

1.4 二叉树的锯齿形层序遍历

题目描述：给定二叉树的根节点root ，返回其节点值的锯齿形层序遍历。即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
题目分析：锯齿形层序遍历的特点是相邻层遍历的顺序相反。在<二叉树层序遍历>的基础上，为实现相邻层遍历顺序相反，可设置标志flag。当flag=true时，从左往右遍历；当flag=false时，从右往左遍历。为实现某一层从右往左遍历，可在处理该层节点时，将其头插至层节点存储向量。

/**
 * 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>> zigzagLevelOrder(TreeNode* root) {
        if(root==nullptr)
        return {};
        vector<vector<int>> res;
        queue<TreeNode*> que;
        bool flag=true;  //flag为真，从左往右遍历；flag为假，从右往左遍历
        que.push(root);
        while(!que.empty()){
            int n=que.size();
            vector<int> tmp;
            TreeNode* node;
            for(int i=0;i<n;i++){
                node=que.front();
                que.pop();
                if(flag==true) tmp.push_back(node->val);
                if(flag==false) tmp.insert(tmp.begin(),node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            flag=!flag;
            res.push_back(tmp);
        }
        return res;
    }
};

1.5 二叉树的最小深度

题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
题目分析：用广度优先搜索方法来实现二叉树最小深度查找时，当某一层某节点无孩子节点，则该节点为叶子节点。

/**
 * 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) {
        if(root==nullptr) 
        return 0;
        if(root->left==nullptr&&root->right==nullptr)
        return 1;
        int res=0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            res++;  //深度加1
            int n=que.size();
            TreeNode* node;
            for(int i=0;i<n;i++){
                node=que.front();
                que.pop();
                if(node->left==nullptr&&node->right==nullptr)
                return res;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

1.6 二叉树的最大深度

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

/**
 * 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) {
        if(root==nullptr)
        return 0;
        int res=0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            res++;  
            TreeNode* node;
            int n=que.size();
            for(int i=0;i<n;i++){  
                node=que.front();
                que.pop();
                if(node->left) que.push(node->left);  //如果该节点还有孩子节点，继续将其孩子节点加入队列  
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

二、N叉树的遍历

2.1 N叉树的层序遍历

题目描述：给定一个N叉树，返回其节点值的层序遍历。即从左到右，逐层遍历。

/*
// 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) {
        if(root==nullptr)
        return {};
        vector<vector<int>> res;
        queue<Node*> que;
        que.push(root);
        while(!que.empty()){
            vector<int> tmp;
            Node* node;
            int n=que.size();
            for(int i=0;i<n;i++){
                node=que.front();
                que.pop();
                tmp.push_back(node->val);
                for(auto child:node->children){  //将该层所有节点的孩子节点入队
                    que.push(child);
                }
            }
            res.push_back(tmp);
        }
        return res;
    }
};