Print nodes in top view of Binary Tree

Top view of a binary tree is the set of nodes visible when the tree is viewed from the top. Given a binary tree, print the top view of it. The output nodes should be printed from left to right.

Note: A node x is there in output if x is the topmost node at its horizontal distance. Horizontal distance of the left child of a node x is equal to the horizontal distance of x minus 1, and that of right child is the horizontal distance of x plus 1.

Input:
       1
    /     \
   2       3
  /  \    / \
 4    5  6   7
Output: Top view: 4 2 1 3 7

Input:
        1
      /   \
    2       3
      \   
        4  
          \
            5
             \
               6
Output: Top view: 2 1 3 6

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The idea is to do something similar to Vertical Order Traversal. Like Vertical Order Traversal, we need to group 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. A Map is used to map the horizontal distance of the node with the node’s Data and vertical distance of the node.

Below is the implementation of the above approach:

C++

// C++ Program to print Top View of Binary Tree 
// using hashmap and recursion 
#include <bits/stdc++.h> 
using namespace std; 
  
// Node structure 
struct Node { 
    // Data of the node 
    int data; 
  
    // Horizontal Distance of the node 
    int hd; 
  
    // Reference to left node 
    struct Node* left; 
  
    // Reference to right node 
    struct Node* right; 
}; 
  
// Initialising node 
struct Node* newNode(int data) 
{ 
    struct Node* node = new Node; 
    node->data = data; 
    node->hd = INT_MAX; 
    node->left = NULL; 
    node->right = NULL; 
    return node; 
} 
  
void printTopViewUtil(Node* root, int height, 
    int hd, map<int, pair<int, int> >& m) 
{ 
    // Base Case 
    if (root == NULL) 
        return; 
  
    // If the node for particular horizontal distance 
    // is not present in the map, add it. 
    // For top view, we consider the first element  
    // at horizontal distance in level order traversal 
    if (m.find(hd) == m.end()) { 
        m[hd] = make_pair(root->data, height); 
    } 
    else{ 
        pair<int, int> p = (m.find(hd))->second; 
                  
        if (p.second > height) { 
            m.erase(hd); 
            m[hd] = make_pair(root->data, height); 
        } 
    } 
  
    // Recur for left and right subtree 
    printTopViewUtil(root->left, height + 1, hd - 1, m); 
    printTopViewUtil(root->right, height + 1, hd + 1, m); 
} 
  
void printTopView(Node* root) 
{ 
    // Map to store horizontal distance,  
    // height and node's data 
    map<int, pair<int, int> > m; 
    printTopViewUtil(root, 0, 0, m); 
  
    // Print the node's value stored by printTopViewUtil() 
    for (map<int, pair<int, int> >::iterator it = m.begin();  
                                        it != m.end(); it++) { 
        pair<int, int> p = it->second; 
        cout << p.first << " "; 
    } 
} 
  
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 << "Top View : "; 
    printTopView(root); 
  
    return 0; 
} 

Java

// Java Program to print Top View of Binary Tree 
// using hashmap and recursion 
import java.util.*; 
  
class GFG 
{ 
  
// Node structure 
static class Node  
{ 
    // Data of the node 
    int data; 
  
    // Reference to left node 
    Node left; 
  
    // Reference to right node 
    Node right; 
}; 
static class pair 
{  
    int data, height;  
    public pair(int data, int height)  
    {  
        this.data = data;  
        this.height = height;  
    }  
}  
  
// Initialising node 
static Node newNode(int data) 
{ 
    Node node = new Node(); 
    node.data = data; 
    node.left = null; 
    node.right = null; 
    return node; 
} 
  
static void printTopViewUtil(Node root, int height, 
                    int hd, Map<Integer, pair > m) 
{ 
    // Base Case 
    if (root == null) 
        return; 
  
    // If the node for particular horizontal distance 
    // is not present in the map, add it. 
    // For top view, we consider the first element  
    // at horizontal distance in level order traversal 
    if (!m.containsKey(hd)) 
    { 
        m.put(hd, new pair(root.data, height)); 
    } 
    else
    { 
        pair p = m.get(hd); 
                  
        if (p.height > height)  
        { 
            m.remove(hd); 
            m.put(hd, new pair(root.data, height)); 
        } 
    } 
  
    // Recur for left and right subtree 
    printTopViewUtil(root.left, height + 1, hd - 1, m); 
    printTopViewUtil(root.right, height + 1, hd + 1, m); 
} 
  
static void printTopView(Node root) 
{ 
    // Map to store horizontal distance,  
    // height and node's data 
    Map<Integer, pair > m = new HashMap<>(); 
    printTopViewUtil(root, 0, 0, m); 
  
    // Print the node's value stored by printTopViewUtil() 
    for (Map.Entry<Integer,pair> it : m.entrySet()) 
    { 
        pair p = it.getValue(); 
        System.out.print(p.data+ " "); 
    } 
} 
  
// 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("Top View : "); 
    printTopView(root); 
} 
} 
  
// This code is contributed by Rajput-Ji 

Python3

# Python3 Program to prTop View of  
# Binary Tree using hash and recursion 
from collections import OrderedDict  
  
# A binary tree node 
class newNode: 
      
    # A constructor to create a  
    # new Binary tree Node 
    def __init__(self, data): 
        self.data = data 
        self.left = None
        self.right = None
        self.hd = 2**32
  
def printTopViewUtil(root, height, hd, m): 
      
    # Base Case 
    if (root == None): 
        return
      
    # If the node for particular horizontal  
    # distance is not present in the map, add it. 
    # For top view, we consider the first element  
    # at horizontal distance in level order traversal 
    if hd not in m : 
        m[hd] = [root.data, height] 
    else: 
        p = m[hd] 
        if p[1] > height: 
            m[hd] = [root.data, height] 
      
    # Recur for left and right subtree 
    printTopViewUtil(root.left,  
                     height + 1, hd - 1, m) 
    printTopViewUtil(root.right,  
                     height + 1, hd + 1, m) 
      
def printTopView(root): 
      
    # to store horizontal distance,  
    # height and node's data 
    m = OrderedDict() 
    printTopViewUtil(root, 0, 0, m) 
      
    # Print the node's value stored  
    # by printTopViewUtil() 
    for i in sorted(list(m)): 
        p = m[i] 
        print(p[0], end = " ") 
  
# Driver Code 
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("Top View : ", end = "") 
printTopView(root) 
  
# This code is contributed by SHUBHAMSINGH10 

Output:

Top View : 2 1 3 6

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Print nodes in top view of Binary Tree | Set 2

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

C++

Java

Python3

Recommended Posts: