# Replace each node in given N-ary Tree with sum of all its subtrees

• Difficulty Level : Medium
• Last Updated : 21 Jan, 2022

Given an N-ary tree. The task is to replace the values of each node with the sum of all its subtrees and the node itself

Examples

Input:            1
/  |  \
2   3    4
/  \     \
5     6     7
Output: Initial Pre-order Traversal: 1 2 5 6 7 3 4
Final Pre-order Traversal: 28 20 5 6 7 3 4
Explanation: Value of each node is replaced by the sum of all its subtrees and the node itself.

Input:            1
/  |  \
4    2   3
/  \           \
7     6           5
Output: Initial Pre-order Traversal: 1 4 7 6  3 5
Final Pre-order Traversal: 23 13 7 6 28 5

Approach: This problem can be solved by using Recursion. Follow the steps below to solve the given problem.

• The easiest way to do this problem is by using recursion.
• Start with the base condition when the current node equals NULL then return 0, as it means it is the leaf node.
• Otherwise, make a recursion call to all its child nodes by traversing using a loop and add the sum of all child nodes in it.
• At last return the current node’s data.
• In this way, all the node’s values will be replaced by the sum of all the subtrees and itself.

Below is the implementation of the above approach.

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Class for the node of the tree``struct` `Node {``    ``int` `data;` `    ``// List of children``    ``struct` `Node** children;` `    ``int` `length;` `    ``Node()``    ``{``        ``length = 0;``        ``data = 0;``    ``}` `    ``Node(``int` `n, ``int` `data_)``    ``{``        ``children = ``new` `Node*();``        ``length = n;``        ``data = data_;``    ``}``};` `// Function to replace node with``// sum of its left subtree, right``// subtree and its sum``int` `sumReplacementNary(Node* node)``{``    ``if` `(node == NULL)``        ``return` `0;` `    ``// Total children count``    ``int` `total = node->length;` `    ``// Taking sum of all the nodes``    ``for` `(``int` `i = 0; i < total; i++)``        ``node->data += sumReplacementNary(node->children[i]);` `    ``return` `node->data;``}` `void` `preorderTraversal(Node* node)``{``    ``if` `(node == NULL)``        ``return``;` `    ``// Total children count``    ``int` `total = node->length;` `    ``// Print the current node's data``    ``cout << node->data << ``" "``;` `    ``// All the children except the last``    ``for` `(``int` `i = 0; i < total - 1; i++)``        ``preorderTraversal(node->children[i]);` `    ``// Last child``    ``preorderTraversal(node->children[total - 1]);``}` `// Driver code``int` `main()``{` `    ``/* Create the following tree``                ``1``              ``/ | \``             ``2  3  4``            ``/ \  \``           ``5  6   7``    ``*/``    ``int` `N = 3;``    ``Node* root = ``new` `Node(N, 1);``    ``root->children = ``new` `Node(N, 2);``    ``root->children = ``new` `Node(N, 3);``    ``root->children = ``new` `Node(N, 4);``    ``root->children->children = ``new` `Node(N, 5);``    ``root->children->children = ``new` `Node(N, 6);``    ``root->children->children = ``new` `Node(N, 7);` `    ``cout << ``"Initial Pre-order Traversal: "``;``    ``preorderTraversal(root);``    ``cout << endl;` `    ``cout << ``"Final Pre-order Traversal: "``;``    ``sumReplacementNary(root);``    ``preorderTraversal(root);``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG{` `  ``// Class for the node of the tree``  ``static` `class` `Node {``    ``int` `data;` `    ``// List of children``    ``Node []children;` `    ``int` `length;` `    ``Node()``    ``{``      ``length = ``0``;``      ``data = ``0``;``    ``}` `    ``Node(``int` `n, ``int` `data_)``    ``{``      ``children = ``new` `Node[n];``      ``length = n;``      ``data = data_;``    ``}``  ``};` `  ``// Function to replace node with``  ``// sum of its left subtree, right``  ``// subtree and its sum``  ``static` `int` `sumReplacementNary(Node node)``  ``{``    ``if` `(node == ``null``)``      ``return` `0``;` `    ``// Total children count``    ``int` `total = node.length;` `    ``// Taking sum of all the nodes``    ``for` `(``int` `i = ``0``; i < total; i++)``      ``node.data += sumReplacementNary(node.children[i]);` `    ``return` `node.data;``  ``}` `  ``static` `void` `preorderTraversal(Node node)``  ``{``    ``if` `(node == ``null``)``      ``return``;` `    ``// Total children count``    ``int` `total = node.length;` `    ``// Print the current node's data``    ``System.out.print(node.data+ ``" "``);` `    ``// All the children except the last``    ``for` `(``int` `i = ``0``; i < total - ``1``; i++)``      ``preorderTraversal(node.children[i]);` `    ``// Last child``    ``preorderTraversal(node.children[total - ``1``]);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``/* Create the following tree``                ``1``              ``/ | \``             ``2  3  4``            ``/ \  \``           ``5  6   7``    ``*/``    ``int` `N = ``3``;``    ``Node root = ``new` `Node(N, ``1``);``    ``root.children[``0``] = ``new` `Node(N, ``2``);``    ``root.children[``1``] = ``new` `Node(N, ``3``);``    ``root.children[``2``] = ``new` `Node(N, ``4``);``    ``root.children[``0``].children[``0``] = ``new` `Node(N, ``5``);``    ``root.children[``0``].children[``1``] = ``new` `Node(N, ``6``);``    ``root.children[``0``].children[``2``] = ``new` `Node(N, ``7``);` `    ``System.out.print(``"Initial Pre-order Traversal: "``);``    ``preorderTraversal(root);``    ``System.out.println();` `    ``System.out.print(``"Final Pre-order Traversal: "``);``    ``sumReplacementNary(root);``    ``preorderTraversal(root);``  ``}``}`

## Python3

 `# Python implementation of the approach` `# Class for the node of the tree``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.children ``=` `[]` `# Function to replace node with``# sum of its left subtree, right``# subtree and its sum``def` `sumReplacementNary(node):``    ``if` `(node ``=``=` `None``):``        ``return` `0` `    ``# Total children count``    ``total ``=` `len``(node.children)` `    ``# Taking sum of all the nodes``    ``for` `i ``in` `range``(``0``, total):``        ``node.data ``+``=` `sumReplacementNary(node.children[i])` `    ``return` `node.data`  `def` `preorderTraversal(node):``    ``if` `(node ``=``=` `None``):``        ``return` `    ``# Total children count``    ``total ``=` `len``(node.children)` `    ``# Print the current node's data``    ``print``(node.data, end``=``" "``)` `    ``# All the children except the last``    ``for` `i ``in` `range``(``0``, total):``        ``preorderTraversal(node.children[i])` `# Driver code``# Create the following tree``#            1``#          / | \``#         2  3  4``#       / \ \``#      5  6  7`  `root ``=` `Node(``1``)``root.children.append(Node(``2``))``root.children.append(Node(``3``))``root.children.append(Node(``4``))``root.children[``0``].children.append(Node(``5``))``root.children[``0``].children.append(Node(``6``))``root.children[``0``].children.append(Node(``7``))` `print``(``"Initial Pre-order Traversal: "``)``preorderTraversal(root)``print``(``"\n"``)` `print``(``"Final Pre-order Traversal: "``)``sumReplacementNary(root)``preorderTraversal(root)`

## C#

 `// C# implementation of the approach``using` `System;``public` `class` `GFG{` `  ``// Class for the node of the tree``  ``class` `Node {``    ``public` `int` `data;` `    ``// List of children``    ``public` `Node []children;``    ``public` `int` `length;` `    ``public` `Node()``    ``{``      ``length = 0;``      ``data = 0;``    ``}` `    ``public` `Node(``int` `n, ``int` `data_)``    ``{``      ``children = ``new` `Node[n];``      ``length = n;``      ``data = data_;``    ``}``  ``};` `  ``// Function to replace node with``  ``// sum of its left subtree, right``  ``// subtree and its sum``  ``static` `int` `sumReplacementNary(Node node)``  ``{``    ``if` `(node == ``null``)``      ``return` `0;` `    ``// Total children count``    ``int` `total = node.length;` `    ``// Taking sum of all the nodes``    ``for` `(``int` `i = 0; i < total; i++)``      ``node.data += sumReplacementNary(node.children[i]);` `    ``return` `node.data;``  ``}` `  ``static` `void` `preorderTraversal(Node node)``  ``{``    ``if` `(node == ``null``)``      ``return``;` `    ``// Total children count``    ``int` `total = node.length;` `    ``// Print the current node's data``    ``Console.Write(node.data+ ``" "``);` `    ``// All the children except the last``    ``for` `(``int` `i = 0; i < total - 1; i++)``      ``preorderTraversal(node.children[i]);` `    ``// Last child``    ``preorderTraversal(node.children[total - 1]);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``/* Create the following tree``                ``1``              ``/ | \``             ``2  3  4``            ``/ \  \``           ``5  6   7``    ``*/``    ``int` `N = 3;``    ``Node root = ``new` `Node(N, 1);``    ``root.children = ``new` `Node(N, 2);``    ``root.children = ``new` `Node(N, 3);``    ``root.children = ``new` `Node(N, 4);``    ``root.children.children = ``new` `Node(N, 5);``    ``root.children.children = ``new` `Node(N, 6);``    ``root.children.children = ``new` `Node(N, 7);` `    ``Console.Write(``"Initial Pre-order Traversal: "``);``    ``preorderTraversal(root);``    ``Console.WriteLine();` `    ``Console.Write(``"Final Pre-order Traversal: "``);``    ``sumReplacementNary(root);``    ``preorderTraversal(root);``  ``}``}`

## Javascript

 ``
Output
```Initial Pre-order Traversal: 1 2 5 6 7 3 4
Final Pre-order Traversal: 28 20 5 6 7 3 4 ```

Time Complexity: O(N), Where N is the number of nodes in the tree.

My Personal Notes arrow_drop_up