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).

&nbsp;
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]]


&nbsp;
Constraints:


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


class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:
            return []
        
        result = []
        level = [root]
        
        while level:
            current_level = []
            next_level = []
            
            for node in level:
                current_level.append(node.val)
                next_level += node.children
                
            result.append(current_level)
            level = next_level
        
        return result
class Solution {
    public List<List<Integer>> result= new ArrayList();
    public List<List<Integer>> levelOrder(Node root) {
       if(root==null) return result;
        helper(root,0);
        return result;
    }
    
    private void helper(Node node,int level){
       if(result.size()<=level){
           result.add(new ArrayList());
       }
        result.get(level).add(node.val);
        for(Node child:node.children){
            helper(child,level+1);
        }
        
    }
}
class Solution {
public:
    
    vector<vector<int>> ans;
    
    vector<vector<int>> levelOrder(Node* root) {
        
        dfs(root, 0);
        return ans;
    }
    
    void dfs(Node* root, int level) {
        
        if(!root) {
            return;
        }
        if(level == ans.size()) {
            ans.push_back({});
        }
        ans[level].push_back(root->val);
        for(auto i : root->children) {
            dfs(i, level+1);
        }
        
    }
    
};
var levelOrder = function(root) {
    if(!root) return [];
    
    const Q  = [[root, 0]];
    const op = [];
    
    while(Q.length) {
        const [node, level] = Q.shift();
        
        if(op.length <= level) {
            op[level] = [];
        }
        op[level].push(node.val);
        
        for(const child of node.children) {
            Q.push([child, level + 1]);
        }
    }
    return op;
};
N-ary Tree Level Order Traversal