Print nodes in top view of Binary Tree | Set 2 - GeeksforGeeks

24 Jun, 2021
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++
Java
Python3
C#
Javascript
// C++ Program to print Top View of Binary Tree// using hashmap and recursion#include <bits/stdc++.h>using namespace std; // Node structurestruct 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 nodestruct 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 Program to print Top View of Binary Tree// using hashmap and recursionimport 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.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 TreeMap<>();        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);    }}
# Python3 Program to prTop View of# Binary Tree using hash and recursionfrom collections import OrderedDict # A binary tree nodeclass 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 Coderoot = 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
// C# program to print Top View of Binary// Tree using hashmap and recursionusing System;using System.Collections.Generic; class GFG{  // Node structureclass Node{         // Data of the node    public int data;     // Reference to left node    public Node left;     // Reference to right node    public Node right;}; class pair{    public int data, height;         public pair(int data, int height)    {        this.data = data;        this.height = height;    }} // Initialising nodestatic 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,                             SortedDictionary<int, 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[hd] = new pair(root.data, height);    }    else    {        pair p = m[hd];         if (p.height >= height)        {            m[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    SortedDictionary<int,                     pair> m = new SortedDictionary<int,                                                    pair>();                                                         printTopViewUtil(root, 0, 0, m);     // Print the node's value stored by    // printTopViewUtil()    foreach(var it in m.Values)    {        Console.Write(it.data + " ");    }} // Driver codepublic 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("Top View : ");         printTopView(root);}} // This code is contributed by rutvik_56
<script> // JavaScript program to print Top View of Binary// Tree using hashmap and recursion // Node structureclass Node{    constructor()    {      // Data of the node      this.data = 0;      // Reference to left node      this.left = null;      // Reference to right node      this.right = null;    }}; class pair{  constructor(data, height)  {    this.data = data;    this.height = height;  }} // Initialising nodefunction newNode(data){    var node = new Node();    node.data = data;    node.left = null;    node.right = null;    return node;} function printTopViewUtil(root, height, hd, 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.has(hd))    {        m.set(hd, new pair(root.data, height));    }    else    {        var p = m.get(hd);         if (p.height >= height)        {            m.set(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);} function printTopView(root){         // Map to store horizontal distance,    // height and node's data    var m = new Map();                                                         printTopViewUtil(root, 0, 0, m);     // Print the node's value stored by    // printTopViewUtil()    for(var it of [...m].sort())    {        document.write(it[1].data + " ");    }} // Driver codevar 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("Top View : ");printTopView(root);  </script>
Top View : 2 1 3 6
SHUBHAMSINGH10
Rajput-Ji
sumantataken
Aman yadav 5
rutvik_56
noob2000
Binary Tree
cpp-map
Hash
Tree Traversals
tree-level-order
tree-view
Tree
Hash
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not
Introduction to Tree Data Structure
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Construct Tree from given Inorder and Preorder traversals
Expression Tree
Lowest Common Ancestor in a Binary Tree | Set 1