# Print nodes in top view of Binary Tree | Set 2

• Difficulty Level : Medium
• Last Updated : 15 Aug, 2022

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

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

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

 `# 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`

## C#

 `// C# program to print Top View of Binary``// Tree using hashmap and recursion``using` `System;``using` `System.Collections.Generic;` `class` `GFG{`` ` `// Node structure``class` `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 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,``                             ``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 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);` `    ``Console.Write(``"Top View : "``);``    ` `    ``printTopView(root);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output

`Top View : 2 1 3 6`

Time complexity: O(n) where n is number of nodes of binary tree

Auxiliary space: O(n) for call stack

My Personal Notes arrow_drop_up