Given an array **arr[]** representing a Generic(N-ary) tree. The task is to replace the node data with the depth(level) of the node. Assume level of root to be 0.

Array Representation: The N-ary tree is serialized in the arrayarr[]using level order traversal as described below:

- The input is given as a level order traversal of N-ary Tree.
- The first element of the array arr[] is the root node.
- Then, followed by a number N, which denotes the number of children of the previous node. Value zero denotes Null Node.

**Examples:**

Input:arr[] = { 10, 3, 20, 30, 40, 2, 40, 50, 0, 0, 0, 0 }

Below is the N-ary Tree of the above array level order traversal:

Output:

Below is the representation of the above output:

Input:arr[] = {1, 3, 2, 3, 4, 2, 5, 6, 0, 0, 2, 8, 9}

Below is the N-ary Tree of the above array level order traversal:

Output:

Below is the representation of the above output:

**Approach:**

- Traverse the tree starting from root.
- While traversing pass depth of node as a parameter.
- Track depth by passing it as 0 for root and (1 + current level) for children.

Below is the implementation of the above approach:

## CPP

`// C++ program to implement node with` `// it's depth value` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Treenode class using template` `template` `<` `typename` `T>` `class` `TreeNode {` `public` `:` ` ` `// To store node value` ` ` `T data;` ` ` `// Pointer to TreeNode to store` ` ` `// the child node` ` ` `vector<TreeNode<T>*> children;` ` ` `// Constructor to assign data` ` ` `// to node` ` ` `TreeNode(T data)` ` ` `{` ` ` `this` `->data = data;` ` ` `}` ` ` `// Destructors to delete a node` ` ` `~TreeNode()` ` ` `{` ` ` `for` `(` `int` `i = 0;` ` ` `i < children.size(); i++) {` ` ` `delete` `children[i];` ` ` `}` ` ` `}` `};` `// Function to take input level wise` `// i.e., in level order traversal` `TreeNode<` `int` `>* takeInputLevelWise(` `int` `arr[])` `{` ` ` `int` `idx = 1;` ` ` `// Input root` ` ` `int` `rootData = arr[0];` ` ` `// Initialize tree with a root node` ` ` `TreeNode<` `int` `>* root` ` ` `= ` `new` `TreeNode<` `int` `>(rootData);` ` ` `// Intialise queue for appending` ` ` `// node as a child of parent in` ` ` `// N-ary tree` ` ` `queue<TreeNode<` `int` `>*> pendingNodes;` ` ` `// Push the root node in queue` ` ` `pendingNodes.push(root);` ` ` `// While queue is not empty append` ` ` `// child to the root` ` ` `while` `(pendingNodes.size() != 0) {` ` ` `// Take the first node` ` ` `TreeNode<` `int` `>* front` ` ` `= pendingNodes.front();` ` ` `pendingNodes.pop();` ` ` `// Input number of child` ` ` `int` `numChild = arr[idx];` ` ` `idx++;` ` ` `for` `(` `int` `i = 0; i < numChild; i++) {` ` ` `int` `childData = arr[idx];` ` ` `idx++;` ` ` `// Make child Node` ` ` `TreeNode<` `int` `>* child` ` ` `= ` `new` `TreeNode<` `int` `>(childData);` ` ` `// Append child node to` ` ` `// it's parent` ` ` `front->children.push_back(child);` ` ` `pendingNodes.push(child);` ` ` `}` ` ` `}` ` ` `return` `root;` `}` `// Function to print each node data` `// in level order` `void` `printLevelATNewLine(TreeNode<` `int` `>* root)` `{` ` ` `queue<TreeNode<` `int` `>*> q;` ` ` `q.push(root);` ` ` `q.push(NULL);` ` ` `while` `(!q.empty()) {` ` ` `TreeNode<` `int` `>* first = q.front();` ` ` `q.pop();` ` ` `if` `(first == NULL) {` ` ` `if` `(q.empty()) {` ` ` `break` `;` ` ` `}` ` ` `cout << endl;` ` ` `q.push(NULL);` ` ` `continue` `;` ` ` `}` ` ` `cout << first->data << ` `" "` `;` ` ` `for` `(` `int` `i = 0;` ` ` `i < first->children.size(); i++) {` ` ` `q.push(first->children[i]);` ` ` `}` ` ` `}` `}` `// Helper function to replace the` `// node data with their level value` `void` `helper(TreeNode<` `int` `>* root,` ` ` `int` `depth)` `{` ` ` `// Replace the node data with` ` ` `// it's depth` ` ` `root->data = depth;` ` ` `for` `(` `int` `i = 0;` ` ` `i < root->children.size(); i++) {` ` ` `helper(root->children[i], depth + 1);` ` ` `}` `}` `// Function to replace with depth` `void` `replaceWithDepthValue(TreeNode<` `int` `>* root)` `{` ` ` `helper(root, 0);` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given level order traversal in` ` ` `// the array arr[]` ` ` `int` `arr[] = { 10, 3, 20, 30, 40, 2,` ` ` `40, 50, 0, 0, 0, 0 };` ` ` `// Intialise Tree` ` ` `TreeNode<` `int` `>* root;` ` ` `root = takeInputLevelWise(arr);` ` ` `// Function call to replace with` ` ` `// depth value` ` ` `replaceWithDepthValue(root);` ` ` `// Function call to print` ` ` `// in level order` ` ` `printLevelATNewLine(root);` ` ` `return` `0;` `}` |

**Output:**

0 1 1 1 2 2

**Time Complexity:** O(N), where N is the number of nodes in Tree. **Auxiliary Space:** O(N), where N is the number of nodes in Tree.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**