Leetcode 429 N叉树的层序遍历——每日一题题解【4.8】外加N叉树的构造

Leetcode 429 N叉树的层序遍历——每日一题题解【4.8】外加N叉树的构造

前言

刚A了今天的每日一题，嗯嗯顺便温习了树的构造方法，即利用数组其实就是层序遍历去构造N叉树，可以参考我之前写的那篇用数组构造二叉树。(1条消息) 根据数组创建二叉树【DS + C++】_物联黄同学的博客-CSDN博客

题目还算简单，基本BFS就行了。

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

小伙伴不妨去练习一下

题目

描述

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示

• 树的高度不会超过 1000
• 树的节点总数在 [0, 10^4] 之间

解题思路【BFS】

因为要层序遍历，所以我们需要使用到广度优先搜索，然后答案要求返回一个二维数组，所以需要记录层数和层的节点数，我们需要把握好队列的尺寸。

Code（C++）

#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<sstream>

using namespace std;

//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:
    /// <summary>
    /// BFS + 队列
    /// 广度优先搜索就可以了
    /// </summary>
    /// <param name="root"></param>
    /// <returns></returns>
    vector<vector<int>> levelOrder(Node* root) 
    {
        // 树空的话直接返回
        if (root == nullptr)
        {
            return {};
        }
        // 队列存储节点
        queue<Node*> que;
        // 二维数组存储答案
        vector<vector<int>> ans;
        // 压入根节点
        que.push(root);
        // 初始化层的尺寸
        int size = 1;
        // 一层的节点值
        vector<int> tmp;
        // 开始BFS
        while (!que.empty())
        {
            // 取出当前节点
            Node* node = que.front();
            size--;
            que.pop();
            tmp.emplace_back(node->val);
            // 子节点入队
            for (auto child : node->children)
            {
                que.push(child);
            }
            // 表示这一层的遍历完了，需要下一层
            if (size == 0)
            {
                // 此时队列尺寸即为下一层的尺寸
                size = que.size();
                ans.push_back(tmp);
                // 清空该层的数组
                tmp.clear();
            }
        }
        return ans;
    }
};

// 写一下n叉树
class NTree
{
public:
    Node* root;     // 根节点

    NTree() {}
    // 利用数组，其实就是层序遍历构造N叉树，需要注意使用字符串数组
    NTree(vector<string>& nodes)
    {
        // 队列存储节点
        queue<Node*> que;
        // 如果树空
        if (nodes.size() == 0)
        {
            return;
        }
        // 获取根节点数值
        int val = stoi(nodes[0]);
        root = new Node(val);
        // 压入根节点
        que.push(root);
        // 索引
        int i = 2;
        // 数组尺寸
        int n = nodes.size();
        // 开始BFS
        while (!que.empty())
        {
            // 获取当前节点
            Node* cur = que.front();
            que.pop();

            // 子节点数组
            vector<Node*> children;
            while (i < n && nodes[i] != "null")
            {
                // 生成节点
                Node* node = new Node(stoi(nodes[i]));
                // 压入队列和子节点数组
                que.push(node);
                children.push_back(node);
                i++;
            }
            if (i < n && nodes[i] == "null")
            {
                i++;
            }
            // 子节点数组连接
            cur->children = children;
        }
    }
};

int main(int argc, char** argv)
{
    int n;
    cin >> n;
    vector<string> nodes(n);
    for (string& node : nodes)
    {
        cin >> node;
    }
    // 创建n叉树对象
    NTree tree(nodes);
    Solution sol;
    auto ans = sol.levelOrder(tree.root);

    int m = ans.size();
    for (int i = 0; i < m; ++i)
    {
        for (int& a : ans[i])
        {
            cout << a << " ";
        }
        cout << endl;
    }

	return 0;
}

后话

没想到，简单的一道题目，搞下来还挺久的，睡了。