# 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++ Program to print Top View of Binary Tree` `// using hashmap and recursion` `#include ` `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 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 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 m = ``new` `TreeMap<>();` `        ``printTopViewUtil(root, ``0``, ``0``, m);`   `        ``// Print the node's value stored by` `        ``// printTopViewUtil()` `        ``for` `(Map.Entry 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 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 `

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.

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.

Practice Tags :