【LeetCode-BFS】二叉树的层序遍历

题目描述

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：

二叉树：[3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]

题目链接： https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

思路

• 首先把根节点入队列，根结点是第一层的节点；
• 循环直至队列为空：
  • 获取队列长度，队列的长度就是当前层的节点个数。依次将当前层的节点出队列并记录，然后当前层节点的子节点入队列；

代码如下：

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

        queue<TreeNode*> q;
        q.push(root);
        vector<vector<int>> ans;
        while(!q.empty()){
            int nodeNums = q.size(); // nodeNums是当前层的节点个数
            vector<int> nodeInCurLayer;  // 存储当前层的节点
            for(int i=0; i<nodeNums; i++){
                TreeNode* curNode = q.front(); q.pop();
                nodeInCurLayer.push_back(curNode->val);
                if(curNode->left!=nullptr) q.push(curNode->left);
                if(curNode->right!=nullptr) q.push(curNode->right);
            }
            ans.push_back(nodeInCurLayer);
        }
        return ans;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(n)

还有一种写法，就是《剑指Offer》里面的写法：

• 设置两个变量 curLayerNodeNums 表示当前层的节点数量，nextLayerNodeNums 表示下一层的节点数量；
• root 入队列，curLayerNodeNums = 1，nextLayerNodeNums = 0；
• 队列不空，循环：
  • 出队列得到当前节点 curNode，curLayerNodeNums--，将 curNode 的子节点入队列，每入一个，nextLayerNodeNums++；
  • 如果 curLayerNodeNums==0，说明当前层的节点已经遍历完毕，进入下一层，将 nextLayerNodeNums 赋值给 curLayerNodeNums，将 nextLayerNodeNums 置为 0 ；

代码如下：

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

        queue<TreeNode*> q;
        q.push(root);
        vector<vector<int>> ans;
        int curLayerNodeNums = 1;
        int nextLayerNodeNums = 0;
        vector<int> nodeInCurLayer;
        while(!q.empty()){
            TreeNode* curNode = q.front(); q.pop();
            nodeInCurLayer.push_back(curNode->val);
            curLayerNodeNums--;
            if(curNode->left!=nullptr){
                q.push(curNode->left);
                nextLayerNodeNums++;
            }
            if(curNode->right!=nullptr){
                q.push(curNode->right);
                nextLayerNodeNums++;
            }
            if(curLayerNodeNums==0){
                ans.push_back(nodeInCurLayer);
                nodeInCurLayer.clear();
                curLayerNodeNums = nextLayerNodeNums;
                nextLayerNodeNums = 0;
            }
        }
        return ans;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(n)