Related Articles
Sum of all vertical levels of a Binary Tree
• Last Updated : 04 Mar, 2021

Given a binary tree consisting of either 1 or 0 as its node values, the task is to find the sum of all vertical levels of the Binary Tree, considering each value to be a binary representation.

Examples:

Input:              1
/     \
1         0
/   \      /   \
1      0  1      0
Output: 7
Explanation:
Taking vertical levels from left to right:
For vertical level 1: (1)2 = 1
For vertical level 2: (1)2 = 1
For vertical level 3: (101)2 = 5
For vertical level 4: (0)2 = 0
For vertical level 5: (0)2 = 0
Total sum = 1+1+5+0+0 = 7

Input:             0
/    \
1       0
/ \         \
1   1          0
/ \   \        / \
1   1   1     0   0
Output: 8
Explanation:
Taking vertical levels from left to right:
For vertical level 1: (1)2 = 1
For vertical level 2: (1)2 = 1
For vertical level 3: (11)2 = 3
For vertical level 4: (01)2 = 1
For vertical level 5: (010)2 = 2
For vertical level 6: (0)2 = 0
For vertical level 7: (0)2 = 0
Total sum = 1+1+3+1+2+0+0 = 8

Approach: Follow the steps below to solve the problem:

1. Perform a tree traversal while keeping track of the horizontal and vertical distance from the root node
2. Store the node value corresponding to its horizontal distance in a Hashmap.
3. Initialize a variable, say ans, to store the required result.
4. Create a Hashmap, say M, to store horizontal distance as key and an array of pairs {node value, distance of the node from the root}.
5. The height for each node is also stored as the vertical level is needed to be in a sorted order (from top to bottom), to get the correct decimal value of its binary representation.
6. Perform preorder tree traversal and also pass vertical height and horizontal distances as parameters.
• If the root is not NULL, perform the following operations:
• Append the pair {node value, vertical height in the horizontal distance} in M.
• Traverse the left subtree, decrementing the horizontal distance by 1.
• Traverse the right subtree, incrementing the horizontal distance by 1.
• Increment the vertical height by 1 for both of the recursive calls.
7. Now, traverse the Hashmap, say M and for every key, perform the following steps:
8. Print the value of ans

Below is the implementation of the above approach:

## C++

 `// C++ program for super ugly number` `#include` `using` `namespace` `std;`   `// Structure of a Tree node` `struct` `TreeNode` `{` `  ``int` `val = 0;` `  ``TreeNode *left;` `  ``TreeNode *right;` `  ``TreeNode(``int` `x)` `  ``{` `    ``val = x;` `    ``left = right = NULL;` `  ``}` `};`   `// Function to convert` `// binary number to decimal` `int` `getDecimal(vector > arr)` `{`   `  ``// Sort the array on` `  ``// the basis of the` `  ``// first index i.e, height` `  ``sort(arr.begin(), arr.end());`   `  ``// Store the required` `  ``// decimal equivalent` `  ``// of the number` `  ``int` `ans = 0;`   `  ``// Traverse the array` `  ``for` `(``int` `i = 0; i < arr.size(); i++)` `  ``{` `    ``ans <<= 1;` `    ``ans |= arr[i].second;` `  ``}`   `  ``// Return the answer` `  ``return` `ans;` `}`   `// Function to traverse the tree` `void` `Traverse(TreeNode *root, ``int` `hd, ``int` `ht,` `              ``map<``int``, vector > > &mp)` `{`   `  ``// If root is NULL, return` `  ``if` `(!root)` `    ``return``;` `  ``mp[hd].push_back({ht, root->val});`   `  ``// Make recursive calls to the left and` `  ``// right subtree` `  ``Traverse(root->left, hd - 1, ht + 1, mp);` `  ``Traverse(root->right, hd + 1, ht + 1, mp);` `}`   `// Function to calculate` `// sum of vertical levels` `// of a Binary Tree` `void` `getSum(TreeNode *root)` `{`   `  ``// Dictionary to store the` `  ``// vertical level as key and` `  ``// its corresponing` `  ``// binary number as value` `  ``map<``int``,vector > > mp;`   `  ``// Function Call to perform traverse the tree` `  ``Traverse(root, 0, 0, mp);`   `  ``// Store the required answer` `  ``int` `ans = 0;`   `  ``// Get decimal values for each vertical level` `  ``// and add it to ans` `  ``for` `(``auto` `i:mp)` `    ``ans += getDecimal(i.second);`   `  ``// Print the answer` `  ``cout<<(ans);` `}`   `/* Driver program to test above functions */` `int` `main()` `{`   `  ``TreeNode *root = ``new` `TreeNode(1);` `  ``root->left = ``new` `TreeNode(1);` `  ``root->right = ``new` `TreeNode(0);` `  ``root->left->left = ``new` `TreeNode(1);` `  ``root->left->right = ``new` `TreeNode(0);` `  ``root->right->left = ``new` `TreeNode(1);` `  ``root->right->right = ``new` `TreeNode(0);`   `  ``// Function call to get the` `  ``// sum of vertical level` `  ``// of the tree` `  ``getSum(root);`   `  ``return` `0;` `}`   `// This code is contriuted by mohit kumar 29.`

## Java

 `// Java program for super ugly number` `import` `java.io.*;` `import` `java.util.*;`   `// Structure of a Tree node` `class` `TreeNode` `{` `  ``int` `val = ``0``;` `  ``TreeNode left;` `  ``TreeNode right;`   `  ``TreeNode(``int` `x)` `  ``{` `    ``val = x;` `    ``left = right = ``null``;` `  ``}` `}`   `class` `GFG {`   `  ``static` `Map>> mp = ``new` `HashMap>>(); `   `  ``// Function to convert` `  ``// binary number to decimal` `  ``static` `int` `getDecimal(ArrayList > arr)` `  ``{`   `    ``// Sort the array on` `    ``// the basis of the` `    ``// first index i.e, height` `    ``Collections.sort(arr, ``new` `Comparator>() {    ` `      ``@Override` `      ``public` `int` `compare(ArrayList o1, ArrayList o2) {` `        ``return` `o1.get(``0``).compareTo(o2.get(``0``));` `      ``}               ` `    ``});`   `    ``// Store the required` `    ``// decimal equivalent` `    ``// of the number` `    ``int` `ans = ``0``;`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < arr.size(); i++)` `    ``{` `      ``ans <<= ``1``;` `      ``ans |= arr.get(i).get(``1``);` `    ``}`   `    ``// Return the answer` `    ``return` `ans;` `  ``}`   `  ``// Function to traverse the tree` `  ``static` `void` `Traverse(TreeNode root, ``int` `hd, ``int` `ht)` `  ``{`   `    ``// If root is NULL, return` `    ``if` `(root == ``null``)` `      ``return``;`   `    ``if``(mp.containsKey(hd))` `    ``{` `      ``mp.get(hd).add(``new` `ArrayList(Arrays.asList(ht, root.val)));` `    ``}` `    ``else` `    ``{` `      ``mp.put(hd,``new` `ArrayList>());` `      ``mp.get(hd).add(``new` `ArrayList(Arrays.asList(ht, root.val)));` `    ``}`   `    ``// Make recursive calls to the left and` `    ``// right subtree` `    ``Traverse(root.left, hd - ``1``, ht + ``1``);` `    ``Traverse(root.right, hd + ``1``, ht + ``1``);` `  ``}`   `  ``// Function to calculate` `  ``// sum of vertical levels` `  ``// of a Binary Tree` `  ``static` `void` `getSum(TreeNode root)` `  ``{`   `    ``// Function Call to perform traverse the tree` `    ``Traverse(root, ``0``, ``0``);`   `    ``// Store the required answer` `    ``int` `ans = ``0``;`   `    ``// Get decimal values for each vertical level` `    ``// and add it to ans` `    ``for``(Integer key : mp.keySet())` `    ``{` `      ``ans += getDecimal(mp.get(key));` `    ``}`   `    ``// Print the answer` `    ``System.out.print(ans);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main (String[] args)` `  ``{` `    ``TreeNode root = ``new` `TreeNode(``1``);` `    ``root.left = ``new` `TreeNode(``1``);` `    ``root.right = ``new` `TreeNode(``0``);` `    ``root.left.left = ``new` `TreeNode(``1``);` `    ``root.left.right = ``new` `TreeNode(``0``);` `    ``root.right.left = ``new` `TreeNode(``1``);` `    ``root.right.right = ``new` `TreeNode(``0``);`   `    ``// Function call to get the` `    ``// sum of vertical level` `    ``// of the tree` `    ``getSum(root);` `  ``}` `}`   `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python program` `# for the above approach`   `# Structure of a Tree node` `class` `TreeNode:` `    ``def` `__init__(``self``, val ``=``'',` `                 ``left ``=` `None``, right ``=` `None``):` `        ``self``.val ``=` `val` `        ``self``.left ``=` `left` `        ``self``.right ``=` `right`   `# Function to convert` `# binary number to decimal` `def` `getDecimal(arr):`   `    ``# Sort the array on` `    ``# the basis of the` `    ``# first index i.e, height` `    ``arr.sort()`   `    ``# Store the required` `    ``# decimal equivalent` `    ``# of the number` `    ``ans ``=` `0`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(``len``(arr)):` `        ``ans <<``=` `1` `        ``ans |``=` `arr[i][``1``]`   `    ``# Return the answer` `    ``return` `ans`   `# Function to calculate` `# sum of vertical levels` `# of a Binary Tree` `def` `getSum(root):`   `    ``# Dictionary to store the` `    ``# vertical level as key and` `    ``# its corresponing` `    ``# binary number as value` `    ``mp ``=` `{}`   `    ``# Function to traverse the tree` `    ``def` `Traverse(root, hd, ht):`   `        ``# If root is NULL, return` `        ``if` `not` `root:` `            ``return`   `        ``# Store the value in the map` `        ``if` `hd ``not` `in` `mp:` `            ``mp[hd] ``=` `[[ht, root.val]]` `        ``else``:` `            ``mp[hd].append([ht, root.val])`   `        ``# Make recursive calls to the left and` `        ``# right subtree` `        ``Traverse(root.left, hd ``-` `1``, ht ``+` `1``)` `        ``Traverse(root.right, hd ``+` `1``, ht ``+` `1``)`   `    ``# Function Call to perform traverse the tree` `    ``Traverse(root, ``0``, ``0``)`   `    ``# Store the required answer` `    ``ans ``=` `0`   `    ``# Get decimal values for each vertical level` `    ``# and add it to ans` `    ``for` `i ``in` `mp:` `        ``ans ``+``=` `getDecimal(mp[i])`   `    ``# Print the answer` `    ``print``(ans)`     `# Driver Code`   `# Given Tree` `root ``=` `TreeNode(``1``)` `root.left ``=` `TreeNode(``1``)` `root.right ``=` `TreeNode(``0``)` `root.left.left ``=` `TreeNode(``1``)` `root.left.right ``=` `TreeNode(``0``)` `root.right.left ``=` `TreeNode(``1``)` `root.right.right ``=` `TreeNode(``0``)`   `# Function call to get the` `# sum of vertical level` `# of the tree` `getSum(root)`

## C#

 `// C# program for super ugly number` `using` `System;` `using` `System.Linq;` `using` `System.Collections.Generic;`   `// Structure of a Tree node` `public` `class` `TreeNode` `{` `  ``public` `int` `val = 0;` `  ``public` `TreeNode left, right;`   `  ``public` `TreeNode(``int` `x)` `  ``{` `    ``val = x;` `    ``left = right = ``null``;` `  ``}` `}`   `public` `class` `GFG` `{`   `  ``static` `Dictionary<``int``,List>> mp = ` `    ``new` `Dictionary<``int``,List>>();`   `  ``// Function to convert` `  ``// binary number to decimal` `  ``static` `int` `getDecimal(List > arr)` `  ``{`   `    ``// Sort the array on` `    ``// the basis of the` `    ``// first index i.e, height` `    ``arr.OrderBy( l => l[0]);`   `    ``// Store the required` `    ``// decimal equivalent` `    ``// of the number` `    ``int` `ans = 0;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < arr.Count; i++)` `    ``{` `      ``ans <<= 1;` `      ``ans |= arr[i][1];` `    ``}`   `    ``// Return the answer` `    ``return` `ans;` `  ``}`   `  ``// Function to traverse the tree` `  ``static` `void` `Traverse(TreeNode root, ``int` `hd, ``int` `ht)` `  ``{`   `    ``// If root is NULL, return` `    ``if` `(root == ``null``)` `      ``return``;`   `    ``if``(mp.ContainsKey(hd))` `    ``{` `      ``mp[hd].Add(``new` `List<``int``>(){ht, root.val});` `    ``}` `    ``else` `    ``{` `      ``mp.Add(hd,``new` `List>());` `      ``mp[hd].Add(``new` `List<``int``>(){ht, root.val});` `    ``}`   `    ``// Make recursive calls to the left and` `    ``// right subtree` `    ``Traverse(root.left, hd - 1, ht + 1);` `    ``Traverse(root.right, hd + 1, ht + 1);` `  ``}`   `  ``// Function to calculate` `  ``// sum of vertical levels` `  ``// of a Binary Tree` `  ``static` `void` `getSum(TreeNode root)` `  ``{`   `    ``// Function Call to perform traverse the tree` `    ``Traverse(root, 0, 0);`   `    ``// Store the required answer` `    ``int` `ans = 0;`   `    ``// Get decimal values for each vertical level` `    ``// and add it to ans` `    ``foreach``(``int` `key ``in` `mp.Keys)` `    ``{` `      ``ans += getDecimal(mp[key]);` `    ``}`   `    ``// Print the answer` `    ``Console.Write(ans);` `  ``}`   `  ``// Driver code` `  ``static` `public` `void` `Main ()` `  ``{` `    ``TreeNode root = ``new` `TreeNode(1);` `    ``root.left = ``new` `TreeNode(1);` `    ``root.right = ``new` `TreeNode(0);` `    ``root.left.left = ``new` `TreeNode(1);` `    ``root.left.right = ``new` `TreeNode(0);` `    ``root.right.left = ``new` `TreeNode(1);` `    ``root.right.right = ``new` `TreeNode(0);`   `    ``// Function call to get the` `    ``// sum of vertical level` `    ``// of the tree` `    ``getSum(root);` `  ``}` `}`   `// This code is contributed by rag2127`

Output:

`7`

Time Complexity: O(N * log(N))
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :