Print nodes in top view of Binary Tree | Set 2

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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


Output:

Top View : 2 1 3 6

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.