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; } |
chevron_right
filter_none
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. |
chevron_right
filter_none
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 */ |
chevron_right
filter_none
Output:
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 non-leaf nodes among all levels of the given binary tree
- Maximum sum of 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
- 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
- Replace node with depth in a binary tree
- Find Minimum Depth of a Binary Tree
- Calculate depth of a full Binary tree from Preorder
- Depth of the deepest odd level node in Binary Tree
- Write a Program to Find the Maximum Depth or Height of a 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.
- Number of triangles formed by joining vertices of n-sided polygon with one side common
- Find the Deepest Node in a Binary Tree Using Queue STL - SET 2
- How to join two Arrays using STL in C++?
- Check if all the 1's in a binary string are equidistant or not
- Remove all consecutive duplicates from a string using STL in C++
- Data Structures and Algorithms Online Courses : Free and Paid
- Introduction to Data Structures | 10 most commonly used Data Structures
- Find the first maximum length even word from a string
- Count the Number of Binary Search Trees present in a Binary Tree
- Why companies like Amazon, Microsoft, Google focuses on Data Structures and Algorithms : Answered
