Sum of nodes in top view of binary tree
Last Updated :
03 Apr, 2023
Top view of a binary tree is the set of nodes visible when the tree is viewed from the top. Given a binary tree, the task is to print the sum of nodes in top view.
Examples:
Input:
1
/ \
2 3
/ \ \
4 5 6
Output: 16
Input:
1
/ \
2 3
\
4
\
5
\
6
Output: 12
Approach: The idea is to put nodes of same horizontal distance together. We do a level order traversal so that the topmost node at a horizontal node is visited before any other node of same horizontal distance below it and we keep summing up their values and store the result in variable sum. Hashing is used to check if a node at given horizontal distance is seen or not.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Structure of binary tree
struct Node {
Node* left;
Node* right;
int hd;
int data;
};
// Function to create a new node
Node* newNode(int key)
{
Node* node = new Node();
node->left = node->right = NULL;
node->data = key;
return node;
}
// Function that returns the sum of
// nodes in top view of binary tree
int SumOfTopView(Node* root)
{
if (root == NULL)
return 0;
queue<Node*> q;
map<int, int> m;
int hd = 0;
root->hd = hd;
int sum = 0;
// Push node and horizontal distance to queue
q.push(root);
while (q.size()) {
hd = root->hd;
// Count function returns 1 if the container
// contains an element whose key is equivalent
// to hd, or returns zero otherwise.
if (m.count(hd) == 0) {
m[hd] = root->data;
sum += m[hd];
}
if (root->left) {
root->left->hd = hd - 1;
q.push(root->left);
}
if (root->right) {
root->right->hd = hd + 1;
q.push(root->right);
}
q.pop();
root = q.front();
}
return sum;
}
// Driver code
int main()
{
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->right = newNode(4);
root->left->right->right = newNode(5);
root->left->right->right->right = newNode(6);
cout << SumOfTopView(root);
return 0;
}
// Java implementation of the approach
import java.util.*;
class Sol
{
// Structure of binary tree
static class Node
{
Node left;
Node right;
int hd;
int data;
};
// Function to create a new node
static Node newNode(int key)
{
Node node = new Node();
node.left = node.right = null;
node.data = key;
return node;
}
// Function that returns the sum of
// nodes in top view of binary tree
static int SumOfTopView(Node root)
{
if (root == null)
return 0;
Queue<Node> q = new LinkedList<Node>();
Map<Integer,Integer> m = new HashMap<Integer,Integer>();
int hd = 0;
root.hd = hd;
int sum = 0;
// Push node and horizontal distance to queue
q.add(root);
while (q.size() > 0)
{
hd = root.hd;
// Count function returns 1 if the container
// contains an element whose key is equivalent
// to hd, or returns zero otherwise.
if (!m.containsKey(hd))
{
m.put(hd, root.data);
sum += m.get(hd);
}
if (root.left != null)
{
root.left.hd = hd - 1;
q.add(root.left);
}
if (root.right != null)
{
root.right.hd = hd + 1;
q.add(root.right);
}
q.remove();
if(q.size() > 0)
root = q.peek();
}
return sum;
}
// Driver code
public static void main(String args[])
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.right = newNode(4);
root.left.right.right = newNode(5);
root.left.right.right.right = newNode(6);
System.out.print(SumOfTopView(root));
}
}
// This code is contributed by Arnab Kundu
# Python3 implementation of the approach
from collections import defaultdict
class Node:
def __init__(self, key):
self.data = key
self.hd = None
self.left = None
self.right = None
# Function that returns the sum of
# nodes in top view of binary tree
def SumOfTopView(root):
if root == None:
return 0
q = []
m = defaultdict(lambda:0)
hd, Sum = 0, 0
root.hd = hd
# Push node and horizontal
# distance to queue
q.append(root)
while len(q) > 0:
hd = root.hd
# Count function returns 1 if
# the container contains an
# element whose key is equivalent
# to hd, or returns zero otherwise.
if m[hd] == 0:
m[hd] = root.data
Sum += m[hd]
if root.left != None:
root.left.hd = hd - 1
q.append(root.left)
if root.right != None:
root.right.hd = hd + 1
q.append(root.right)
q.pop(0)
if len(q) > 0:
root = q[0]
return Sum
# Driver code
if __name__ == "__main__":
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.right = Node(4)
root.left.right.right = Node(5)
root.left.right.right.right = Node(6)
print(SumOfTopView(root))
# This code is contributed by Rituraj Jain
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
// Structure of binary tree
public class Node
{
public Node left;
public Node right;
public int hd;
public int data;
};
// Function to create a new node
static Node newNode(int key)
{
Node node = new Node();
node.left = node.right = null;
node.data = key;
return node;
}
// Function that returns the sum of
// nodes in top view of binary tree
static int SumOfTopView(Node root)
{
if (root == null)
return 0;
Queue<Node> q = new Queue<Node>();
Dictionary<int,
int> m = new Dictionary<int,
int>();
int hd = 0;
root.hd = hd;
int sum = 0;
// Push node and horizontal distance to queue
q.Enqueue(root);
while (q.Count > 0)
{
hd = root.hd;
// Count function returns 1 if the container
// contains an element whose key is equivalent
// to hd, or returns zero otherwise.
if (!m.ContainsKey(hd))
{
m.Add(hd, root.data);
sum += m[hd];
}
if (root.left != null)
{
root.left.hd = hd - 1;
q.Enqueue(root.left);
}
if (root.right != null)
{
root.right.hd = hd + 1;
q.Enqueue(root.right);
}
q.Dequeue();
if(q.Count > 0)
root = q.Peek();
}
return sum;
}
// Driver code
public static void Main(String []args)
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.right = newNode(4);
root.left.right.right = newNode(5);
root.left.right.right.right = newNode(6);
Console.Write(SumOfTopView(root));
}
}
// This code is contributed by Princi Singh
<script>
// JavaScript implementation of the approach
// Structure of binary tree
class Node
{
constructor(key) {
this.left = null;
this.right = null;
this.data = key;
this.hd;
}
}
// Function to create a new node
function newNode(key)
{
let node = new Node(key);
return node;
}
// Function that returns the sum of
// nodes in top view of binary tree
function SumOfTopView(root)
{
if (root == null)
return 0;
let q = [];
let m = new Map();
let hd = 0;
root.hd = hd;
let sum = 0;
// Push node and horizontal distance to queue
q.push(root);
while (q.length > 0)
{
hd = root.hd;
// Count function returns 1 if the container
// contains an element whose key is equivalent
// to hd, or returns zero otherwise.
if (!m.has(hd))
{
m.set(hd, root.data);
sum += m.get(hd);
}
if (root.left != null)
{
root.left.hd = hd - 1;
q.push(root.left);
}
if (root.right != null)
{
root.right.hd = hd + 1;
q.push(root.right);
}
q.shift();
if(q.length > 0)
root = q[0];
}
return sum;
}
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.right = newNode(4);
root.left.right.right = newNode(5);
root.left.right.right.right = newNode(6);
document.write(SumOfTopView(root));
</script>
Time Complexity: O(N)
Auxiliary Space: O(N)
Approach:
To solve the problem follow the below idea:
Here we use the two variables, one for the vertical distance of the current node from the root and another for the depth of the current node from the root. We use the vertical distance for indexing. If one node with the same vertical distance comes again, we check if the depth of the new node is lower or higher with respect to the current node with the same vertical distance in the map. If the depth of the new node is lower, then we replace it.
Follow the below steps to solve the problem:
1) Create a map of the type <int, pair<int, int>> and two variables d and l to store horizontal and vertical distance from the root respectively
2) Call the function to return the SumOfTopView
3) If the root is equal to the null value then return from the function (Base case)
4) Check if this value of d is not present in the map, then set map[d] equal to {root->data, l}
5) Check if this value of d is already present and its vertical distance is greater than l, then set map[d] equal to {root->data, l}
6) Call this function recursively for (root->left, d-1, l+1, mp) and (root->right, d+1, l+1, mp)
7) return the sum of top view of the binary tree using the map
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Structure of binary tree
struct Node {
Node* left;
Node* right;
int data;
};
// function to create a new node
Node* newNode(int data){
Node* temp = new Node();
temp->left = temp->right = NULL;
temp->data = data;
return temp;
}
// function to fill the map
void fillMap(Node* root, int d, int l, map<int, pair<int, int> >& m){
if (root == NULL) return;
if (m.count(d) == 0)
m[d] = make_pair(root->data, l);
else if(m[d].second > l)
m[d] = make_pair(root->data, l);
fillMap(root->left, d - 1, l + 1, m);
fillMap(root->right, d + 1, l + 1, m);
}
// function return the SumofTopView of
// the given binary tree
int SumOfTopView(Node* root){
// map to store the pair of node value and its level
// with respect to the vertical distance from root.
map<int, pair<int, int> > m;
// Initializing map
fillMap(root, 0, 0, m);
int ans = 0;
for(auto i : m){
ans += i.second.first;
}
return ans;
}
// Driver code
int main(){
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->right = newNode(4);
root->left->right->right = newNode(5);
root->left->right->right->right = newNode(6);
cout<<SumOfTopView(root);
return 0;
}
// this code is contributed by Yash Agarwal(yashagarwal2852002)
import java.util.*;
// structure of binary tree node
class Node {
int data;
Node left, right;
Node(int data) {
this.data = data;
left = null;
right = null;
}
}
// pair class
class Pair {
int first, second;
Pair(int first, int second) {
this.first = first;
this.second = second;
}
}
class Solution {
// function to fill the map
public void fillMap(Node root, int d, int l, Map<Integer, Pair> m) {
if (root == null)
return;
if (m.get(d) == null) {
m.put(d, new Pair(root.data, l));
} else if (m.get(d).second > 1) {
m.put(d, new Pair(root.data, l));
}
fillMap(root.left, d-1, l+1, m);
fillMap(root.right, d+1, l+1, m);
}
// function returns the sumofTopView of the given binary tree
public int sumOfTopView(Node root) {
// map to store the pair of node value and its level
// with respect to the vertical distance from root
Map<Integer, Pair> m = new TreeMap<>();
// initializing map
fillMap(root, 0, 0, m);
int ans = 0;
for(Integer x: m.keySet()) {
ans += m.get(x).first;
}
return ans;
}
// driver program to test above functions
public static void main(String[] args) {
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(4);
root.left.right.right = new Node(5);
root.left.right.right.right = new Node(6);
Solution s = new Solution();
System.out.println(s.sumOfTopView(root));
}
}
# Python program for the above approach
# structure of binary tree node
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# pair class
class pair:
def __init__(self, first, second):
self.first = first
self.second = second
# function to create a new node
def newNode(data):
return Node(data)
# function to fill the map
def fillMap(root, d, l, m):
if(root is None):
return
if(m.get(d) is None):
m[d] = pair(root.data, l)
elif(m.get(d).second > 1):
m[d] = pair(root.data, l)
fillMap(root.left, d-1, l+1, m)
fillMap(root.right, d+1, l+1, m)
# function returns the sumofTopView of
# the given binary tree
def SumOfTopView(root):
# map to store the pair of node value and its level
# with respect to the vertical distance from root
m = {}
# initializing map
fillMap(root, 0, 0, m)
ans = 0
for x in m:
ans += m[x].first
return ans
# driver program to test above functions
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.right = newNode(4)
root.left.right.right = newNode(5)
root.left.right.right.right = newNode(6)
print(SumOfTopView(root))
// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
// Structure of binary tree
class Node {
public Node left;
public Node right;
public int data;
public Node(int val){
data = val;
left = null;
right = null;
}
}
class HelloWorld {
// function to fill the map
public static void fillMap(Node root, int d, int l, IDictionary<int, KeyValuePair<int,int> > m){
if (root == null) return;
if (m.ContainsKey(d) == false)
m.Add(new KeyValuePair<int, KeyValuePair<int,int>>(d, new KeyValuePair<int, int>(root.data, l)));
else if(m[d].Value > 1){
m[d] = new KeyValuePair<int,int>(root.data, l);
}
fillMap(root.left, d - 1, l + 1, m);
fillMap(root.right, d + 1, l + 1, m);
}
// function return the SumofTopView of
// the given binary tree
public static int SumOfTopView(Node root)
{
// map to store the pair of node value and its level
// with respect to the vertical distance from root.
IDictionary<int, KeyValuePair<int,int> > m = new Dictionary<int, KeyValuePair<int,int>>();
// Initializing map
fillMap(root, 0, 0, m);
int ans = 0;
foreach(KeyValuePair<int, KeyValuePair<int,int>> i in m)
{
ans += i.Value.Key;
// do something with entry.Value or entry.Key
}
return ans;
}
static void Main() {
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(4);
root.left.right.right = new Node(5);
root.left.right.right.right = new Node(6);
Console.WriteLine(SumOfTopView(root));
}
}
// The code is contributed by Nidhi goel.
// JavaScript program for the above approach
// structure of binary tree node
class Node{
constructor(data){
this.data = data;
this.left = null;
this.right = null;
}
}
// pair class
class pair{
constructor(first, second){
this.first = first;
this.second = second;
}
}
// function to create a new node
function newNode(data){
return new Node(data);
}
// functiont o fill the map
function fillMap(root, d, l, m){
if(root == null) return;
if(m.has(d) == false)
m.set(d, new pair(root.data, l));
else if(m.get(d).second > 1)
m.set(d, new pair(root.data, l));
fillMap(root.left, d-1, l+1, m);
fillMap(root.right, d+1, l+1, m);
}
// function return the SumOfTopView of
// the given binary tree
function SumOfTopView(root){
// map to store the pair of node value and its level
// with respect to the vertical distance from root
let m = new Map();
// initializing map
fillMap(root, 0, 0, m);
let ans = 0;
m.forEach(function(value, key){
ans += value.first;
})
return ans;
}
// driver code
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.right = newNode(4);
root.left.right.right = newNode(5);
root.left.right.right.right = newNode(6);
document.write(SumOfTopView(root));
// THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL(KIRTIAGARWAL23121999)
Time complexity: O(N * log(N)), where N is the number of nodes in the given binary tree.
Auxiliary Space: O(N)
Similar Reads
Sum of nodes in bottom view of Binary Tree
Given a binary tree, the task is to return the sum of nodes in the bottom view of the given Binary Tree. The bottom view of a binary tree is the set of nodes visible when the tree is viewed from the bottom. Note: If there are multiple bottom-most nodes for a horizontal distance from the root, then t
15+ min read
Print Nodes in Top View of Binary Tree
Given a binary tree. The task is to find the top view of the binary tree. The top view of a binary tree is the set of nodes visible when the tree is viewed from the top. Note: Return the nodes from the leftmost node to the rightmost node.If two nodes are at the same position (horizontal distance) an
15+ min read
Sum of nodes in the left view of the given binary tree
Given a binary tree, the task is to find the sum of the nodes which are visible in the left view. The left view of a binary tree is the set of nodes visible when the tree is viewed from the left.Examples: Example 1 : The Green colored nodes represents the left view in the below Binary tree. The Left
13 min read
Sum of nodes in the right view of the given binary tree
Given a binary tree, the task is to find the sum of the nodes which are visible in the right view. The right view of a binary tree is the set of nodes visible when the tree is viewed from the right.Examples: Input: 1 / \ 2 3 / \ \ 4 5 6Output: 101 + 3 + 6 = 10Input: 1 / \ 2 3 \ 4 \ 5 \ 6Output: 19Ap
15+ min read
Sum of all leaf nodes of binary tree
Given a binary tree, find the sum of all the leaf nodes.Examples: Input : 1 / \ 2 3 / \ / \ 4 5 6 7 \ 8 Output : Sum = 4 + 5 + 8 + 7 = 24 Recommended PracticeSum of Leaf NodesTry It! The idea is to traverse the tree in any fashion and check if the node is the leaf node or not. If the node is the lea
5 min read
Sum of all nodes in a binary tree
Give an algorithm for finding the sum of all elements in a binary tree. In the above binary tree sum = 106. Recommended PracticeSum of Binary TreeTry It!The idea is to recursively, call left subtree sum, right subtree sum and add their values to current node's data. Implementation: C++ /* Program to
15+ min read
Sum of all the Boundary Nodes of a Binary Tree
Given a binary tree, the task is to print the sum of all the boundary nodes of the tree. Examples: Input: 1 / \ 2 3 / \ / \ 4 5 6 7 Output: 28 Input: 1 / \ 2 3 \ / 4 5 \ 6 / \ 7 8 Output: 36 Approach: We have already discussed the Boundary Traversal of a Binary tree. Here we will find the sum of the
10 min read
Find sum of all nodes of the given perfect binary tree
Given a positive integer L which represents the number of levels in a perfect binary tree. Given that the leaf nodes in this perfect binary tree are numbered starting from 1 to n, where n is the number of leaf nodes. And the parent node is the sum of the two child nodes. Our task is to write a progr
11 min read
Count the number of visible nodes in Binary Tree
Given a Binary tree, the task is to find the number of visible nodes in the given binary tree. A node is a visible node if, in the path from the root to the node N, there is no node with greater value than N’s, Examples: Input: 5 / \ 3 10 / \ / 20 21 1 Output: 4 Explanation: There are 4 visible node
7 min read
Sum of nodes at maximum depth of a Binary Tree
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 While traversing the nodes compare th
15+ min read