Sum of nodes at maximum depth of a Binary Tree | Set 2
Given a root node to a tree, find the sum of all the leaf nodes which are at maximum depth from root node.
Example:
1 / \ 2 3 / \ / \ 4 5 6 7 Input : root(of above tree) Output : 22 Explanation: Nodes at maximum depth are: 4, 5, 6, 7. So, sum of these nodes = 22
In the previous article we discussed a recursive solution which first finds the maximum level and then finds the sum of all nodes present at that level.
In this article we will see a recursive solution without finding the height or depth. The idea is that while traversing the nodes compare the level of the node with max_level (Maximum level till the current node). If the current level exceeds the maximum level, update the max_level as current level. If the max level and current level are same, add the root data to current sum otherwise if level is less than max_level, do nothing.
Below is the implementation of the above approach:
C++
// C++ Program to find sum of nodes at maximum // Depth of the Binary Tree #include <bits/stdc++.h> using namespace std; // Variables to store sum and // maximum level int sum = 0, max_level = INT_MIN; // Binary Tree Node struct Node { int data; Node* left; Node* right; }; // Utility function to create and // return a new Binary Tree Node Node* createNode( int val) { Node* node = new Node; node->data = val; node->left = NULL; node->right = NULL; return node; } // Function to find the sum of the node which // are present at the maximum depth void sumOfNodesAtMaxDepth(Node* root, int level) { if (root == NULL) return ; // If the current level exceeds the // maximum level, update the max_level // as current level. if (level > max_level) { sum = root->data; max_level = level; } // If the max level and current level // are same, add the root data to // current sum. else if (level == max_level) { sum = sum + root->data; } // Traverse the left and right subtrees sumOfNodesAtMaxDepth(root->left, level + 1); sumOfNodesAtMaxDepth(root->right, level + 1); } // Driver Code int main() { Node* root; root = createNode(1); root->left = createNode(2); root->right = createNode(3); root->left->left = createNode(4); root->left->right = createNode(5); root->right->left = createNode(6); root->right->right = createNode(7); sumOfNodesAtMaxDepth(root, 0); cout << sum; return 0; } |
Java
// Java Program to find sum of nodes at maximum // Depth of the Binary Tree class GfG { // Variables to store sum and // maximum level static int sum = 0 , max_level = Integer.MIN_VALUE; // Binary Tree Node static class Node { int data; Node left; Node right; } // Utility function to create and // return a new Binary Tree Node static Node createNode( int val) { Node node = new Node(); node.data = val; node.left = null ; node.right = null ; return node; } // Function to find the sum of // the node which are present // at the maximum depth static void sumOfNodesAtMaxDepth(Node root, int level) { if (root == null ) return ; // If the current level exceeds the // maximum level, update the max_level // as current level. if (level > max_level) { sum = root.data; max_level = level; } // If the max level and current level // are same, add the root data to // current sum. else if (level == max_level) { sum = sum + root.data; } // Traverse the left and right subtrees sumOfNodesAtMaxDepth(root.left, level + 1 ); sumOfNodesAtMaxDepth(root.right, level + 1 ); } // Driver Code public static void main(String[] args) { Node root = null ; root = createNode( 1 ); root.left = createNode( 2 ); root.right = createNode( 3 ); root.left.left = createNode( 4 ); root.left.right = createNode( 5 ); root.right.left = createNode( 6 ); root.right.right = createNode( 7 ); sumOfNodesAtMaxDepth(root, 0 ); System.out.println(sum); } } // This code is contributed by // Prerna Saini. |
Python3
# Python3 Program to find sum of nodes at maximum # Depth of the Binary Tree # Variables to store sum and # maximum level sum = [ 0 ] max_level = [ - ( 2 * * 32 )] # Binary tree node class createNode: def __init__( self , data): self .data = data self .left = None self .right = None # Function to find the sum of the node which # are present at the maximum depth def sumOfNodesAtMaxDepth(root, level): if (root = = None ): return # If the current level exceeds the # maximum level, update the max_level # as current level. if (level > max_level[ 0 ]): sum [ 0 ] = root.data max_level[ 0 ] = level # If the max level and current level #are same, add the root data to # current sum. elif (level = = max_level[ 0 ]): sum [ 0 ] = sum [ 0 ] + root.data # Traverse the left and right subtrees sumOfNodesAtMaxDepth(root.left, level + 1 ) sumOfNodesAtMaxDepth(root.right, level + 1 ) # Driver Code root = createNode( 1 ) root.left = createNode( 2 ) root.right = createNode( 3 ) root.left.left = createNode( 4 ) root.left.right = createNode( 5 ) root.right.left = createNode( 6 ) root.right.right = createNode( 7 ) sumOfNodesAtMaxDepth(root, 0 ) print ( sum [ 0 ]) # This code is contributed by SHUBHAMSINGH10 |
C#
// C# Program to find sum of nodes at maximum // Depth of the Binary Tree using System; public class GfG { // Variables to store sum and // maximum level static int sum = 0, max_level = int .MinValue; // Binary Tree Node class Node { public int data; public Node left; public Node right; } // Utility function to create and // return a new Binary Tree Node static Node createNode( int val) { Node node = new Node(); node.data = val; node.left = null ; node.right = null ; return node; } // Function to find the sum of // the node which are present // at the maximum depth static void sumOfNodesAtMaxDepth(Node root, int level) { if (root == null ) return ; // If the current level exceeds the // maximum level, update the max_level // as current level. if (level > max_level) { sum = root.data; max_level = level; } // If the max level and current level // are same, add the root data to // current sum. else if (level == max_level) { sum = sum + root.data; } // Traverse the left and right subtrees sumOfNodesAtMaxDepth(root.left, level + 1); sumOfNodesAtMaxDepth(root.right, level + 1); } // Driver Code public static void Main() { Node root = null ; root = createNode(1); root.left = createNode(2); root.right = createNode(3); root.left.left = createNode(4); root.left.right = createNode(5); root.right.left = createNode(6); root.right.right = createNode(7); sumOfNodesAtMaxDepth(root, 0); Console.WriteLine(sum); } } /* This code is contributed PrinciRaj1992 */ |
22
Recommended Posts:
- Sum of nodes at maximum depth of a Binary Tree
- Sum of nodes at maximum depth of a Binary Tree | Iterative Approach
- Find maximum among all right nodes in Binary Tree
- Maximum sum of nodes in Binary tree such that no two are adjacent
- Maximum sum of leaf nodes among all levels of the given binary tree
- Maximum sum of non-leaf nodes among all levels of the given binary tree
- Maximum sum of nodes in Binary tree such that no two are adjacent | Dynamic Programming
- Queries to find the maximum Xor value between X and the nodes of a given level of a perfect binary tree
- Find maximum count of duplicate nodes in a Binary Search Tree
- Maximum length cycle that can be formed by joining two nodes of a binary tree
- Minimum and maximum node that lies in the path connecting two nodes in a Binary Tree
- Find Minimum Depth of a Binary Tree
- Replace node with depth in a binary tree
- Calculate depth of a full Binary tree from Preorder
- Depth of the deepest odd level node in Binary Tree
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.