LeetCode 429. N-ary Tree Level Order Traversal

原题链接在这里：https://leetcode.com/problems/n-ary-tree-level-order-traversal/

题目：

Given an n-ary tree, return the level order traversal of its nodes' values.

Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).

Example 1:

Input: root = [1,null,3,2,4,null,5,6]
Output: [[1],[3,2,4],[5,6]]

Example 2:

Input: 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]
Output: [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

Constraints:

• The height of the n-ary tree is less than or equal to 1000
• The total number of nodes is between [0, 10^4]

题解：

When iterating by BFS, for current level nodes, get the size of queue. Iterate each of them.

Add node's value to item and if any of its children is not null, add them to queue.

Time Complexity: O(V+E). V is node count. E is edge count.

Space: O(V).

AC Java:

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

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        
        LinkedList<Node> que = new LinkedList<>();
        que.add(root);
        while(!que.isEmpty()){
            int size = que.size();
            List<Integer> item = new ArrayList<>();
            while(size-- > 0){
                Node cur = que.poll();
                item.add(cur.val);
                for(Node node : cur.children){
                    if(node != null){
                        que.add(node);
                    }
                }
            }
            
            res.add(item);
        }
        
        return res;
    }
}

AC C++:

/*
// 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) {
        vector<vector<int>> res;
        if(!root){
            return res;
        }

        queue<Node*> que;
        que.push(root);

        while(!que.empty()){
            int size = que.size();
            vector<int> item;
            while(size-- > 0){
                Node* cur = que.front();
                que.pop();
                item.push_back(cur->val);
                for(Node* child : cur->children){
                    if(child){
                        que.push(child);
                    }
                }
            }

            res.push_back(item);
        }

        return res;
    }
};

AC Python:

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        res = []
        if not root:
            return res
        
        que = deque([root])
        while que:
            size = len(que)
            item = []
            for i in range(size):
                cur = que.popleft()
                item.append(cur.val)
                for child in cur.children:
                    if child:
                        que.append(child)
            
            res.append(item)
        return res
        

类似Binary Tree Level Order Traversal, N-ary Tree Preorder Traversal.