429. N-ary Tree Level Order Traversal

最新推荐文章于 2020-04-17 11:41:34 发布

石前有座桥

最新推荐文章于 2020-04-17 11:41:34 发布

阅读量108

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode-easy

本文链接：https://blog.youkuaiyun.com/lyw_321/article/details/95672891

leetcode-easy 专栏收录该内容

121 篇文章

订阅专栏

博客围绕N叉树的层序遍历展开，要求返回节点值的层序遍历结果，即从左到右、逐层输出。还提到树的深度和节点总数有一定限制，同时给出递归和迭代两种思路的参考。

Given an n-ary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example, given a 3-ary tree:

We should return its level order traversal:

[
     [1],
     [3,2,4],
     [5,6]
]

Note:

The depth of the tree is at most 1000.
The total number of nodes is at most 5000.

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>ans;
        if(!root){
            return ans;
        }
        int depth=0,i,j,n;
        queue<Node*>q;
        q.push(root);
        while(!q.empty()){
            vector<int>a;
            n=q.size();
            for(i=0;i<n;i++){
                Node* head=q.front();
                q.pop();
                a.push_back(head->val);
                for(j=0;j<head->children.size();j++){
                    q.push(head->children[j]);
                }
            }
            ans.push_back(a);
        }
        return ans;
    }
};

递归和迭代思路参考这里

递归：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>>ans;
    
    vector<vector<int>> levelOrder(Node* root) {        
        if(!root){
            return ans;
        }
        queue<Node*>q;
        q.push(root);
        bfs(q);
        return ans;
    }
    
    void bfs(queue<Node*>q){
        if(q.empty()){
            return;
        }
        queue<Node*>nextq;
        vector<int>a;
        int i;
        while(!q.empty()){
            Node* head=q.front();
            q.pop();
            a.push_back(head->val);
            for(i=0;i<head->children.size();i++){
                nextq.push(head->children[i]);
            }
        }
        ans.push_back(a);
        bfs(nextq);
    }
};

迭代：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>>ans;
    
    vector<vector<int>> levelOrder(Node* root) {        
        if(!root){
            return ans;
        }
        queue<Node*>q;
        q.push(root);
        bfs(q);
        return ans;
    }
    
    void bfs(queue<Node*>q){
        if(q.empty()){
            return;
        }
        while(!q.empty()){
            queue<Node*>nextq;
            vector<int>a;
            int i;
            while(!q.empty()){
             Node* head=q.front();
                q.pop();
                a.push_back(head->val);
                for(i=0;i<head->children.size();i++){
                    nextq.push(head->children[i]);
                }
            }
            ans.push_back(a);
            q=nextq;
        }
    }
};