Given the root of an n-ary tree, return the preorder 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,5,6,2,4]


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,6,7,11,14,4,8,12,5,9,13,10]


&nbsp;
Constraints:


	The number of nodes in the tree is in the range [0, 104].
	0 &lt;= Node.val &lt;= 104
	The height of the n-ary tree is less than or equal to 1000.


&nbsp;
Follow up: Recursive solution is trivial, could you do it iteratively?

function preorder(root: Node | null): number[] {
  const res: number[] = [];

  const getNodeVal = (node: Node | null): void => {
    if (node) {
      res.push(node.val);

      for (let i = 0; i < node.children.length; i++) {
        getNodeVal(node.children[i]);
      }
    }
  };

  getNodeVal(root);

  return res;
}
class Solution {
    public List<Integer> preorder(Node root) {
        if (root == null) return new ArrayList<Integer>();
        
        Stack<Node> stk = new Stack<Node>();
        ArrayList<Integer> arr = new ArrayList<Integer>();
        stk.push(root);
        Node ref;
        while(!stk.empty()) {
            ref = stk.pop();
            // System.out.println(ref.val);
            arr.add(ref.val);
            for(int i=ref.children.size() - 1;i>=0;i--) {
                stk.push(ref.children.get(i));
            }
        }
        return arr;
    }
}
class Solution {
public:
    vector<int> preorder(Node* root) {
        vector<int>ans;
        stack<Node*>st;
        st.push(root);
        while(!st.empty()){
            auto frnt=st.top();
            st.pop();
            ans.push_back(frnt->val);
            for(int i=frnt->children.size()-1;i>=0;i--){
                st.push(frnt->children[i]);
            }
        }
        return ans;
    }
};
var preorder = function(root) {
    return [root.val].concat(root.children.map( (c)=>c ? preorder(c) : [] ).flat() );
};
N-ary Tree Preorder Traversal