Sum of nodes at maximum depth of a Binary Tree | Iterative Approach

Given a root node to a tree, find the sum of all the leaf nodes which are at maximum depth from root node.


    /   \
   2     3
  / \   / \
 4   5 6   7

Input : root(of above tree)
Output : 22

Nodes at maximum depth are 4, 5, 6, 7. 
So, the sum of these nodes = 22

Approach: There exists a recursive approach to this problem. This can also be solved using level order traversal and map. The idea is to do a traversal using a queue and keep track of current level. A map has been used to store the sum of nodes at the current level. Once all nodes are visited and the traversal is done, the last element of the map will contain the sum at the maximum depth of the tree.

Below is the implementation of the above approach:

// C++ program to calculate the sum of
// nodes at the maximum depth of a binary tree
#include <bits/stdc++.h>
using namespace std;

struct node {
    int data;
    node *left, *right;
} * temp;

node* newNode(int data)
    temp = new node;
    temp->data = data;
    temp->left = temp->right = NULL;

    return temp;

// Function to return the sum
int SumAtMaxLevel(node* root)
    // Map to store level wise sum.
    map<int, int> mp;

    // Queue for performing Level Order Traversal.
    // First entry is the node and
    // second entry is the level of this node.
    queue<pair<node*, int> > q;

    // Root has level 0.
    q.push({ root, 0 });

    while (!q.empty()) {

        // Get the node from front of Queue.
        pair<node*, int> temp = q.front();

        // Get the depth of current node.
        int depth = temp.second;

        // Add the value of this node in map.
        mp[depth] += (temp.first)->data;

        // Push children of this node,
        // with increasing the depth.
        if (temp.first->left)
            q.push({ temp.first->left, depth + 1 });

        if (temp.first->right)
            q.push({ temp.first->right, depth + 1 });

    map<int, int>::iterator it;

    // Get the max depth from map.
    it = mp.end();

    // last element

    // return the max Depth sum.
    return it->second;

// Driver Code
int main()
    node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->left = newNode(6);
    root->right->right = newNode(7);

    cout << SumAtMaxLevel(root) << endl;
    return 0;


A Coding Enthusiast Rails Developer

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

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Recommended Posts:

3 Average Difficulty : 3/5.0
Based on 1 vote(s)