# Find Maximum Level Sum in Binary Tree using Recursion

Given a Binary Tree having positive and negative nodes, the task is to find the maximum sum level in it and print the maximum sum.

Examples:

```Input:
4
/   \
2     -5
/ \    / \
-1   3 -2   6
Output: 6
Sum of all nodes of the 1st level is 4.
Sum of all nodes of the 2nd level is -3.
Sum of all nodes of the 3rd level is 6.
Hence, the maximum sum is 6.

Input:
1
/   \
2      3
/  \      \
4    5      8
/   \
6     7
Output: 17
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Find the maximum level in the given binary tree then create an array sum[] where sum[i] will store the sum of the elements at level i.
Now, write a recursive function that takes a node of the tree and its level as the argument and updates the sum for the current level then makes recursive calls for the children with the updated level as one more than the current level (this is because children are at a level one more than their parent). Finally, print the maximum value from the sum[] array.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// A binary tree node has data, pointer to ` `// the left child and the right child ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `// Helper function that allocates a ` `// new node with the given data and ` `// NULL left and right pointers ` `struct` `Node* newNode(``int` `data) ` `{ ` `    ``struct` `Node* node = ``new` `Node; ` `    ``node->data = data; ` `    ``node->left = node->right = NULL; ` `    ``return` `(node); ` `} ` ` `  `// Function to return the maximum ` `// levels in the given tree ` `int` `maxLevel(``struct` `Node* root) ` `{ ` `    ``if` `(root == NULL) ` `        ``return` `0; ` `    ``return` `(1 + max(maxLevel(root->left), ` `                    ``maxLevel(root->right))); ` `} ` ` `  `// Function to find the maximum sum of a ` `// level in the tree using recursion ` `void` `maxLevelSum(``struct` `Node* root, ``int` `max_level, ` `                 ``int` `sum[], ``int` `current) ` `{ ` `    ``// Base case ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// Add current node's data to ` `    ``// its level's sum ` `    ``sum[current] += root->data; ` ` `  `    ``// Recursive call for the left child ` `    ``maxLevelSum(root->left, max_level, sum, ` `                ``current + 1); ` ` `  `    ``// Recursive call for the right child ` `    ``maxLevelSum(root->right, max_level, sum, ` `                ``current + 1); ` `} ` ` `  `// Function to find the maximum sum of a ` `// level in the tree using recursion ` `int` `maxLevelSum(``struct` `Node* root) ` `{ ` ` `  `    ``// Maximum levels in the given tree ` `    ``int` `max_level = maxLevel(root); ` ` `  `    ``// To store the sum of every level ` `    ``int` `sum[max_level + 1] = { 0 }; ` ` `  `    ``// Recursive function call to ` `    ``// update the sum[] array ` `    ``maxLevelSum(root, max_level, sum, 1); ` ` `  `    ``// To store the maximum sum for a level ` `    ``int` `maxSum = 0; ` ` `  `    ``// For every level of the tree, update ` `    ``// the maximum sum of a level so far ` `    ``for` `(``int` `i = 1; i <= max_level; i++) ` `        ``maxSum = max(maxSum, sum[i]); ` ` `  `    ``// Return the maximum sum ` `    ``return` `maxSum; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``struct` `Node* root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right->right = newNode(8); ` `    ``root->right->right->left = newNode(6); ` `    ``root->right->right->right = newNode(7); ` ` `  `    ``/* Constructed Binary tree is:  ` `                ``1  ` `               ``/ \  ` `              ``2   3  ` `             ``/ \   \  ` `            ``4   5   8  ` `                   ``/ \  ` `                  ``6   7   */` ` `  `    ``cout << maxLevelSum(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `class` `GFG ` `{ ` ` `  `// A binary tree node has data, pointer to ` `// the left child and the right child ` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` ` `  `// Helper function that allocates a ` `// new node with the given data and ` `// null left and right pointers ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node node = ``new` `Node(); ` `    ``node.data = data; ` `    ``node.left = node.right = ``null``; ` `    ``return` `(node); ` `} ` ` `  `// Function to return the maximum ` `// levels in the given tree ` `static` `int` `maxLevel( Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return` `0``; ` `    ``return` `(``1` `+ Math.max(maxLevel(root.left), ` `                     ``maxLevel(root.right))); ` `} ` ` `  `// Function to find the maximum sum of a ` `// level in the tree using recursion ` `static` `void` `maxLevelSum(Node root, ``int` `max_level, ` `                        ``int` `sum[], ``int` `current) ` `{ ` `    ``// Base case ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``// Add current node's data to ` `    ``// its level's sum ` `    ``sum[current] += root.data; ` ` `  `    ``// Recursive call for the left child ` `    ``maxLevelSum(root.left, max_level, sum, ` `                ``current + ``1``); ` ` `  `    ``// Recursive call for the right child ` `    ``maxLevelSum(root.right, max_level, sum, ` `                ``current + ``1``); ` `} ` ` `  `// Function to find the maximum sum of a ` `// level in the tree using recursion ` `static` `int` `maxLevelSum( Node root) ` `{ ` ` `  `    ``// Maximum levels in the given tree ` `    ``int` `max_level = maxLevel(root); ` ` `  `    ``// To store the sum of every level ` `    ``int` `sum[] = ``new` `int``[max_level + ``1``]; ` ` `  `    ``// Recursive function call to ` `    ``// update the sum[] array ` `    ``maxLevelSum(root, max_level, sum, ``1``); ` ` `  `    ``// To store the maximum sum for a level ` `    ``int` `maxSum = ``0``; ` ` `  `    ``// For every level of the tree, update ` `    ``// the maximum sum of a level so far ` `    ``for` `(``int` `i = ``1``; i <= max_level; i++) ` `        ``maxSum = Math.max(maxSum, sum[i]); ` ` `  `    ``// Return the maximum sum ` `    ``return` `maxSum; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``Node root = newNode(``1``); ` `    ``root.left = newNode(``2``); ` `    ``root.right = newNode(``3``); ` `    ``root.left.left = newNode(``4``); ` `    ``root.left.right = newNode(``5``); ` `    ``root.right.right = newNode(``8``); ` `    ``root.right.right.left = newNode(``6``); ` `    ``root.right.right.right = newNode(``7``); ` ` `  `    ``/* Coned Binary tree is:  ` `                ``1  ` `            ``/ \  ` `            ``2 3  ` `            ``/ \ \  ` `            ``4 5 8  ` `                ``/ \  ` `                ``6 7 */` ` `  `    ``System.out.println(maxLevelSum(root)); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python

 `# Python implementation of above algorithm ` ` `  `# Utility class to create a node  ` `class` `Node:  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.val ``=` `key  ` `        ``self``.left ``=` `self``.right ``=` `None` ` `  `# Helper function that allocates a ` `# new node with the given data and ` `# None left and right pointers ` `def` `newNode(data): ` ` `  `    ``node ``=` `Node(``0``) ` `    ``node.data ``=` `data ` `    ``node.left ``=` `node.right ``=` `None` `    ``return` `(node) ` ` `  `# Function to return the maximum ` `# levels in the given tree ` `def` `maxLevel( root): ` ` `  `    ``if` `(root ``=``=` `None``): ` `        ``return` `0` `    ``return` `(``1` `+` `max``(maxLevel(root.left), ` `                    ``maxLevel(root.right))) ` ` `  `sum` `=` `[] ` ` `  `# Function to find the maximum sum of a ` `# level in the tree using recursion ` `def` `maxLevelSum_( root, max_level , current): ` ` `  `    ``global` `sum` `     `  `    ``# Base case ` `    ``if` `(root ``=``=` `None``): ` `        ``return` ` `  `    ``# Add current node's data to ` `    ``# its level's sum ` `    ``sum``[current] ``+``=` `root.data ` ` `  `    ``# Recursive call for the left child ` `    ``maxLevelSum_(root.left, max_level,  ` `                ``current ``+` `1``) ` ` `  `    ``# Recursive call for the right child ` `    ``maxLevelSum_(root.right, max_level, ` `                ``current ``+` `1``) ` ` `  `# Function to find the maximum sum of a ` `# level in the tree using recursion ` `def` `maxLevelSum( root): ` ` `  `    ``global` `sum` `     `  `    ``# Maximum levels in the given tree ` `    ``max_level ``=` `maxLevel(root) ` ` `  `    ``# To store the sum of every level ` `    ``i ``=` `0` `    ``sum` `=` `[``None``] ``*` `(max_level ``+` `2``) ` `    ``while``(i <``=` `max_level ``+` `1``): ` `        ``sum``[i] ``=` `0` `        ``i ``=` `i ``+` `1` ` `  `    ``# Recursive function call to ` `    ``# update the sum[] array ` `    ``maxLevelSum_(root, max_level, ``1``) ` ` `  `    ``# To store the maximum sum for a level ` `    ``maxSum ``=` `0` ` `  `    ``# For every level of the tree, update ` `    ``# the maximum sum of a level so far ` `    ``i ``=` `1` `    ``while` `( i <``=` `max_level ): ` `        ``maxSum ``=` `max``(maxSum, ``sum``[i]) ` `        ``i ``=` `i ``+` `1` ` `  `    ``# Return the maximum sum ` `    ``return` `maxSum ` ` `  `# Driver code ` `root ``=` `newNode(``1``) ` `root.left ``=` `newNode(``2``) ` `root.right ``=` `newNode(``3``) ` `root.left.left ``=` `newNode(``4``) ` `root.left.right ``=` `newNode(``5``) ` `root.right.right ``=` `newNode(``8``) ` `root.right.right.left ``=` `newNode(``6``) ` `root.right.right.right ``=` `newNode(``7``) ` ` `  `# Constructed Binary tree is:  ` `#             1  ` `#             / \  ` `#             2 3  ` `#         / \ \  ` `#         4 5 8  ` `#                 / \  ` `#                 6 7  ` `     `  ` `  `print``( maxLevelSum(root)) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# implementation of the approach ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// A binary tree node has data,  ` `// pointer to the left child  ` `// and the right child ` `public` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `}; ` ` `  `// Helper function that allocates a ` `// new node with the given data and ` `// null left and right pointers ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node node = ``new` `Node(); ` `    ``node.data = data; ` `    ``node.left = node.right = ``null``; ` `    ``return` `(node); ` `} ` ` `  `// Function to return the maximum ` `// levels in the given tree ` `static` `int` `maxLevel( Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return` `0; ` `    ``return` `(1 + Math.Max(maxLevel(root.left), ` `                         ``maxLevel(root.right))); ` `} ` ` `  `// Function to find the maximum sum of a ` `// level in the tree using recursion ` `static` `void` `maxLevelSum(Node root, ``int` `max_level, ` `                        ``int` `[]sum, ``int` `current) ` `{ ` `    ``// Base case ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``// Add current node's data to ` `    ``// its level's sum ` `    ``sum[current] += root.data; ` ` `  `    ``// Recursive call for the left child ` `    ``maxLevelSum(root.left, max_level,  ` `                ``sum, current + 1); ` ` `  `    ``// Recursive call for the right child ` `    ``maxLevelSum(root.right, max_level,  ` `                ``sum, current + 1); ` `} ` ` `  `// Function to find the maximum sum of a ` `// level in the tree using recursion ` `static` `int` `maxLevelSum( Node root) ` `{ ` ` `  `    ``// Maximum levels in the given tree ` `    ``int` `max_level = maxLevel(root); ` ` `  `    ``// To store the sum of every level ` `    ``int` `[]sum = ``new` `int``[max_level + 1]; ` ` `  `    ``// Recursive function call to ` `    ``// update the sum[] array ` `    ``maxLevelSum(root, max_level, sum, 1); ` ` `  `    ``// To store the maximum sum for a level ` `    ``int` `maxSum = 0; ` ` `  `    ``// For every level of the tree, update ` `    ``// the maximum sum of a level so far ` `    ``for` `(``int` `i = 1; i <= max_level; i++) ` `        ``maxSum = Math.Max(maxSum, sum[i]); ` ` `  `    ``// Return the maximum sum ` `    ``return` `maxSum; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``Node root = newNode(1); ` `    ``root.left = newNode(2); ` `    ``root.right = newNode(3); ` `    ``root.left.left = newNode(4); ` `    ``root.left.right = newNode(5); ` `    ``root.right.right = newNode(8); ` `    ``root.right.right.left = newNode(6); ` `    ``root.right.right.right = newNode(7); ` ` `  `    ``/* Coned Binary tree is:  ` `                ``1  ` `            ``/ \  ` `            ``2 3  ` `            ``/ \ \  ` `            ``4 5 8  ` `                ``/ \  ` `                ``6 7 */` ` `  `    ``Console.WriteLine(maxLevelSum(root)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```17
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : andrew1234, Rajput-Ji

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.