# Print Nodes in Top View of Binary Tree

• Difficulty Level : Medium
• Last Updated : 09 Nov, 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 can be printed in any order.

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

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

```       1
/     \
2       3
/  \    / \
4    5  6   7
Top view of the above binary tree is
4 2 1 3 7

1
/   \
2       3
\
4
\
5
\
6
Top view of the above binary tree is
2 1 3 6```

The idea is to do something similar to vertical Order Traversal. Like vertical Order Traversal, we need to put 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. Hashing is used to check if a node at given horizontal distance is seen or not.

## C++

 `// C++ program to print top``// view of binary tree` `#include ``using` `namespace` `std;` `// Structure of binary tree``struct` `Node {``    ``Node* left;``    ``Node* right;``    ``int` `hd;``    ``int` `data;``};` `// function to create a new node``Node* newNode(``int` `key)``{``    ``Node* node = ``new` `Node();``    ``node->left = node->right = NULL;``    ``node->data = key;``    ``return` `node;``}` `// function should print the topView of``// the binary tree``void` `topview(Node* root)``{``    ``if` `(root == NULL)``        ``return``;``    ``queue q;``    ``map<``int``, ``int``> m;``    ``int` `hd = 0;``    ``root->hd = hd;` `    ``// push node and horizontal distance to queue``    ``q.push(root);` `    ``cout << ``"The top view of the tree is : \n"``;` `    ``while` `(q.size()) {``        ``hd = root->hd;` `        ``// count function returns 1 if the container``        ``// contains an element whose key is equivalent``        ``// to hd, or returns zero otherwise.``        ``if` `(m.count(hd) == 0)``            ``m[hd] = root->data;``        ``if` `(root->left) {``            ``root->left->hd = hd - 1;``            ``q.push(root->left);``        ``}``        ``if` `(root->right) {``            ``root->right->hd = hd + 1;``            ``q.push(root->right);``        ``}``        ``q.pop();``        ``root = q.front();``    ``}` `    ``for` `(``auto` `i = m.begin(); i != m.end(); i++) {``        ``cout << i->second << ``" "``;``    ``}``}` `// Driver Program to test above functions``int` `main()``{``    ``/* Create following Binary Tree``            ``1``        ``/ \``        ``2 3``        ``\``            ``4``            ``\``            ``5``            ``\``                ``6*/``    ``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 << ``"Following are nodes in top view of Binary "``            ``"Tree\n"``;``    ``topview(root);``    ``return` `0;``}``/* This code is contributed by Niteesh Kumar */`

## Java

 `// Java program to print top``// view of binary tree``import` `java.util.LinkedList;``import` `java.util.Map;``import` `java.util.Map.Entry;``import` `java.util.Queue;``import` `java.util.TreeMap;` `// class to create a node``class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``public` `Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``}` `// class of binary tree``class` `BinaryTree {``    ``Node root;` `    ``public` `BinaryTree() { root = ``null``; }` `    ``// function should print the topView of``    ``// the binary tree``    ``private` `void` `TopView(Node root)``    ``{``        ``class` `QueueObj {``            ``Node node;``            ``int` `hd;` `            ``QueueObj(Node node, ``int` `hd)``            ``{``                ``this``.node = node;``                ``this``.hd = hd;``            ``}``        ``}``        ``Queue q = ``new` `LinkedList();``        ``Map topViewMap``            ``= ``new` `TreeMap();` `        ``if` `(root == ``null``) {``            ``return``;``        ``}``        ``else` `{``            ``q.add(``new` `QueueObj(root, ``0``));``        ``}` `        ``System.out.println(``            ``"The top view of the tree is : "``);` `        ``// count function returns 1 if the container``        ``// contains an element whose key is equivalent``        ``// to hd, or returns zero otherwise.``        ``while` `(!q.isEmpty()) {``            ``QueueObj tmpNode = q.poll();``            ``if` `(!topViewMap.containsKey(tmpNode.hd)) {``                ``topViewMap.put(tmpNode.hd, tmpNode.node);``            ``}` `            ``if` `(tmpNode.node.left != ``null``) {``                ``q.add(``new` `QueueObj(tmpNode.node.left,``                                   ``tmpNode.hd - ``1``));``            ``}``            ``if` `(tmpNode.node.right != ``null``) {``                ``q.add(``new` `QueueObj(tmpNode.node.right,``                                   ``tmpNode.hd + ``1``));``            ``}``        ``}``        ``for` `(Entry entry :``             ``topViewMap.entrySet()) {``            ``System.out.print(entry.getValue().data);``        ``}``    ``}` `    ``// Driver Program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``/* Create following Binary Tree``            ``1``        ``/ \``        ``2 3``        ``\``            ``4``            ``\``            ``5``            ``\``                ``6*/``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``1``);``        ``tree.root.left = ``new` `Node(``2``);``        ``tree.root.right = ``new` `Node(``3``);``        ``tree.root.left.right = ``new` `Node(``4``);``        ``tree.root.left.right.right = ``new` `Node(``5``);``        ``tree.root.left.right.right.right = ``new` `Node(``6``);``        ``System.out.println(``            ``"Following are nodes in top view of Binary Tree"``);``        ``tree.TopView(tree.root);``    ``}``}`

## Python3

 `# Python3 program to print top``# view of binary tree` `# Binary Tree Node``""" utility that allocates a newNode``with the given key """`  `class` `newNode:` `    ``# Construct to create a newNode``    ``def` `__init__(``self``, key):``        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None``        ``self``.hd ``=` `0` `# function should print the topView``# of the binary tree`  `def` `topview(root):` `    ``if``(root ``=``=` `None``):``        ``return``    ``q ``=` `[]``    ``m ``=` `dict``()``    ``hd ``=` `0``    ``root.hd ``=` `hd` `    ``# push node and horizontal``    ``# distance to queue``    ``q.append(root)` `    ``while``(``len``(q)):``        ``root ``=` `q[``0``]``        ``hd ``=` `root.hd` `        ``# count function returns 1 if the``        ``# container contains an element``        ``# whose key is equivalent to hd,``        ``# or returns zero otherwise.``        ``if` `hd ``not` `in` `m:``            ``m[hd] ``=` `root.data``        ``if``(root.left):``            ``root.left.hd ``=` `hd ``-` `1``            ``q.append(root.left)` `        ``if``(root.right):``            ``root.right.hd ``=` `hd ``+` `1``            ``q.append(root.right)` `        ``q.pop(``0``)``    ``for` `i ``in` `sorted``(m):``        ``print``(m[i], end``=``"")`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``""" Create following Binary Tree``            ``1``        ``/ \``        ``2 3``        ``\``            ``4``            ``\``            ``5``            ``\``                ``6*"""``    ``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``(``"Following are nodes in top"``,``          ``"view of Binary Tree"``)``    ``topview(root)` `# This code is contributed by``# Shubham Singh(SHUBHAMSINGH10)`

## C#

 `// C# program to print top``// view of binary tree``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `// Class to create a node``class` `Node {``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``};` `class` `QueueObj {``    ``public` `Node node;``    ``public` `int` `hd;` `    ``public` `QueueObj(Node node, ``int` `hd)``    ``{``        ``this``.node = node;``        ``this``.hd = hd;``    ``}``};` `// Class of binary tree``class` `BinaryTree {` `    ``Node root;` `    ``public` `BinaryTree() { root = ``null``; }` `    ``// function should print the topView of``    ``// the binary tree``    ``void` `TopView(Node root)``    ``{``        ``Queue q = ``new` `Queue();``        ``SortedDictionary<``int``, Node> topViewMap``            ``= ``new` `SortedDictionary<``int``, Node>();` `        ``if` `(root == ``null``) {``            ``return``;``        ``}``        ``else` `{``            ``q.Enqueue(``new` `QueueObj(root, 0));``        ``}` `        ``// count function returns 1 if the container``        ``// contains an element whose key is equivalent``        ``// to hd, or returns zero otherwise.``        ``while` `(q.Count != 0) {``            ``QueueObj tmpNode = (QueueObj)q.Dequeue();` `            ``if` `(!topViewMap.ContainsKey(tmpNode.hd)) {``                ``topViewMap[tmpNode.hd] = tmpNode.node;``            ``}` `            ``if` `(tmpNode.node.left != ``null``) {``                ``q.Enqueue(``new` `QueueObj(tmpNode.node.left,``                                       ``tmpNode.hd - 1));``            ``}``            ``if` `(tmpNode.node.right != ``null``) {``                ``q.Enqueue(``new` `QueueObj(tmpNode.node.right,``                                       ``tmpNode.hd + 1));``            ``}``        ``}` `        ``foreach``(``var` `entry ``in` `topViewMap.Values)``        ``{``            ``Console.Write(entry.data);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{` `        ``/* Create following Binary Tree``            ``1``           ``/ \``          ``2   3``           ``\``            ``4``             ``\``              ``5``               ``\``                ``6*/``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(1);``        ``tree.root.left = ``new` `Node(2);``        ``tree.root.right = ``new` `Node(3);``        ``tree.root.left.right = ``new` `Node(4);``        ``tree.root.left.right.right = ``new` `Node(5);``        ``tree.root.left.right.right.right = ``new` `Node(6);` `        ``Console.WriteLine(``"Following are nodes "``                          ``+ ``"in top view of Binary Tree"``);` `        ``tree.TopView(tree.root);``    ``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``
Output

```Following are nodes in top view of Binary Tree
The top view of the tree is :
2 1 3 6 ```

Another approach:
This approach does not require a queue. Here we use the two variables, one for vertical distance of current node from the root and another for the depth of the current node from the root. We use the vertical distance for indexing. If one node with the same vertical distance comes again, we check if depth of new node is lower or higher with respect to the current node with same vertical distance in the map. If depth of new node is lower, then we replace it.

## C++

 `#include ``using` `namespace` `std;` `// Structure of binary tree``struct` `Node {``    ``Node* left;``    ``Node* right;``    ``int` `data;``};` `// function to create a new node``Node* newNode(``int` `key)``{``    ``Node* node = ``new` `Node();``    ``node->left = node->right = NULL;``    ``node->data = key;``    ``return` `node;``}` `// function to fill the map``void` `fillMap(Node* root, ``int` `d, ``int` `l,``             ``map<``int``, pair<``int``, ``int``> >& m)``{``    ``if` `(root == NULL)``        ``return``;` `    ``if` `(m.count(d) == 0) {``        ``m[d] = make_pair(root->data, l);``    ``}``    ``else` `if` `(m[d].second > l) {``        ``m[d] = make_pair(root->data, l);``    ``}` `    ``fillMap(root->left, d - 1, l + 1, m);``    ``fillMap(root->right, d + 1, l + 1, m);``}` `// function should print the topView of``// the binary tree``void` `topView(``struct` `Node* root)``{` `    ``// map to store the pair of node value and its level``    ``// with respect to the vertical distance from root.``    ``map<``int``, pair<``int``, ``int``> > m;` `    ``// fillmap(root,vectical_distance_from_root,level_of_node,map)``    ``fillMap(root, 0, 0, m);` `    ``for` `(``auto` `it = m.begin(); it != m.end(); it++) {``        ``cout << it->second.first << ``" "``;``    ``}``}``// Driver Program to test above functions``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 << ``"Following are nodes in top view of Binary "``            ``"Tree\n"``;``    ``topView(root);``    ``return` `0;``}``/* This code is contributed by Akash Debnath */`

## Java

 `// Java program to print top``// view of binary tree``import` `java.util.*;` `class` `GFG {` `    ``// Structure of binary tree``    ``static` `class` `Node {``        ``Node left;``        ``Node right;``        ``int` `data;``    ``}` `    ``static` `class` `pair {``        ``int` `first, second;` `        ``pair() {}``        ``pair(``int` `i, ``int` `j)``        ``{``            ``first = i;``            ``second = j;``        ``}``    ``}` `    ``// map to store the pair of node value and``    ``// its level with respect to the vertical``    ``// distance from root.``    ``static` `TreeMap m = ``new` `TreeMap<>();` `    ``// function to create a new node``    ``static` `Node newNode(``int` `key)``    ``{``        ``Node node = ``new` `Node();``        ``node.left = node.right = ``null``;``        ``node.data = key;``        ``return` `node;``    ``}` `    ``// function to fill the map``    ``static` `void` `fillMap(Node root, ``int` `d, ``int` `l)``    ``{``        ``if` `(root == ``null``)``            ``return``;` `        ``if` `(m.get(d) == ``null``) {``            ``m.put(d, ``new` `pair(root.data, l));``        ``}``        ``else` `if` `(m.get(d).second > l) {``            ``m.put(d, ``new` `pair(root.data, l));``        ``}` `        ``fillMap(root.left, d - ``1``, l + ``1``);``        ``fillMap(root.right, d + ``1``, l + ``1``);``    ``}` `    ``// function should print the topView of``    ``// the binary tree``    ``static` `void` `topView(Node root)``    ``{``        ``fillMap(root, ``0``, ``0``);` `        ``for` `(Map.Entry entry :``             ``m.entrySet()) {``            ``System.out.print(entry.getValue().first + ``" "``);``        ``}``    ``}` `    ``// 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.println(``"Following are nodes in"``                           ``+ ``" top view of Binary Tree"``);``        ``topView(root);``    ``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Binary Tree Node``""" utility that allocates a newNode``with the given key """`  `class` `newNode:` `    ``# Construct to create a newNode``    ``def` `__init__(``self``, key):``        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# function to fill the map`  `def` `fillMap(root, d, l, m):``    ``if``(root ``=``=` `None``):``        ``return` `    ``if` `d ``not` `in` `m:``        ``m[d] ``=` `[root.data, l]``    ``elif``(m[d][``1``] > l):``        ``m[d] ``=` `[root.data, l]``    ``fillMap(root.left, d ``-` `1``, l ``+` `1``, m)``    ``fillMap(root.right, d ``+` `1``, l ``+` `1``, m)` `# function should print the topView of``# the binary tree`  `def` `topView(root):` `    ``# map to store the pair of node value and its level``    ``# with respect to the vertical distance from root.``    ``m ``=` `{}` `    ``fillMap(root, ``0``, ``0``, m)``    ``for` `it ``in` `sorted``(m.keys()):``        ``print``(m[it][``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``(``"Following are nodes in top view of Binary Tree"``)``topView(root)` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program to print top``// view of binary tree``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG {` `    ``// Structure of binary tree``    ``class` `Node {``        ``public` `Node left;``        ``public` `Node right;``        ``public` `int` `data;``    ``}` `    ``class` `pair {``        ``public` `int` `first, second;` `        ``public` `pair(``int` `i, ``int` `j)``        ``{``            ``first = i;``            ``second = j;``        ``}``    ``}` `    ``// map to store the pair of node value and``    ``// its level with respect to the vertical``    ``// distance from root.``    ``static` `SortedDictionary<``int``, pair> m``        ``= ``new` `SortedDictionary<``int``, pair>();` `    ``// function to create a new node``    ``static` `Node newNode(``int` `key)``    ``{``        ``Node node = ``new` `Node();``        ``node.left = node.right = ``null``;``        ``node.data = key;``        ``return` `node;``    ``}` `    ``// function to fill the map``    ``static` `void` `fillMap(Node root, ``int` `d, ``int` `l)``    ``{``        ``if` `(root == ``null``)``            ``return``;` `        ``if` `(!m.ContainsKey(d)) {``            ``m[d] = ``new` `pair(root.data, l);``        ``}``        ``else` `if` `(m[d].second > l) {``            ``m[d] = ``new` `pair(root.data, l);``        ``}` `        ``fillMap(root.left, d - 1, l + 1);``        ``fillMap(root.right, d + 1, l + 1);``    ``}` `    ``// function should print the topView of``    ``// the binary tree``    ``static` `void` `topView(Node root)``    ``{``        ``fillMap(root, 0, 0);` `        ``foreach``(pair entry ``in` `m.Values)``        ``{``            ``Console.Write(entry.first + ``" "``);``        ``}``    ``}` `    ``// 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.WriteLine(``"Following are nodes in"``                          ``+ ``" top view of Binary Tree"``);``        ``topView(root);``    ``}``}` `// This code is contributed by pratham76`

## Javascript

 ``
Output
```Following are nodes in top view of Binary Tree
2 1 3 6 ```

This approach is contributed by Akash Debnath

Time Complexity of the above implementation is O(nlogn) where n is the number of nodes in the given binary tree with each insertion operation in Map requiring O(log2n) complexity.

Another approach:

1. This approach is based on the level order traversal. We’ll keep record of current max so far left, right horizontal distances from the root.
2. And if we found less distance (or greater in magnitude) then max left so far distance then update it and also push data on this node to a stack (stack is used because in level order traversal the left nodes will appear in reverse order), or if we found greater distance then max right so far distance then update it and also push data on this node to a vector.
3. In this approach, no map is used.

## C++14

 `// C++ Program to print Top View of a binary Tree` `#include ``#include ``#include ``using` `namespace` `std;` `// class for Tree node``class` `Node {``public``:``    ``Node *left, *right;``    ``int` `data;``    ``Node() { left = right = 0; }``    ``Node(``int` `data)``    ``{``        ``left = right = 0;``        ``this``->data = data;``    ``}``};` `/*``          ``1``         ``/ \``        ``2   3``         ``\``          ``4``           ``\``            ``5``             ``\``              ``6``    ``Top view of the above binary tree is``    ``2 1 3 6``*/` `// class for Tree``class` `Tree {``public``:``    ``Node* root;``    ``Tree() { root = 0; }` `    ``void` `topView()``    ``{``        ``// queue for holding nodes and their horizontal``        ``// distance from the root node``        ``queue > q;` `        ``// pushing root node with distance 0``        ``q.push(make_pair(root, 0));` `        ``// hd is currect node's horizontal distance from``        ``// root node l is currect left min horizontal``        ``// distance (or max in magnitude) so far from the``        ``// root node r is currect right max horizontal``        ``// distance so far from the root node` `        ``int` `hd = 0, l = 0, r = 0;` `        ``// stack is for holding left node's data because``        ``// they will appear in reverse order that is why``        ``// using stack``        ``stack<``int``> left;` `        ``// vector is for holding right node's data``        ``vector<``int``> right;` `        ``Node* node;` `        ``while` `(q.size()) {` `            ``node = q.front().first;``            ``hd = q.front().second;` `            ``if` `(hd < l) {``                ``left.push(node->data);``                ``l = hd;``            ``}``            ``else` `if` `(hd > r) {``                ``right.push_back(node->data);``                ``r = hd;``            ``}` `            ``if` `(node->left) {``                ``q.push(make_pair(node->left, hd - 1));``            ``}``            ``if` `(node->right) {``                ``q.push(make_pair(node->right, hd + 1));``            ``}` `            ``q.pop();``        ``}``        ``// printing the left node's data in reverse order``        ``while` `(left.size()) {``            ``cout << left.top() << ``" "``;``            ``left.pop();``        ``}` `        ``// then printing the root node's data``        ``cout << root->data << ``" "``;` `        ``// finally printing the right node's data``        ``for` `(``auto` `x : right) {``            ``cout << x << ``" "``;``        ``}``    ``}``};` `// Driver code``int` `main()``{``    ``// Tree object``    ``Tree t;``    ``t.root = ``new` `Node(1);``    ``t.root->left = ``new` `Node(2);``    ``t.root->right = ``new` `Node(3);``    ``t.root->left->right = ``new` `Node(4);``    ``t.root->left->right->right = ``new` `Node(5);``    ``t.root->left->right->right->right = ``new` `Node(6);``    ``t.topView();``    ``cout << endl;``    ``return` `0;``}`
Output
`2 1 3 6 `

This approach is contributed by Surat Prakash Maurya.

As no Map is used, Time Complexity of the above implementation is O(n) where n is the number of nodes in the given binary tree.

Another Approach:

This approach is built upon the level order traversal with hash map approach discussed above. I just made a simple tweek to reduce the overall time complexity of the algorithm.

Since sorting is involved, the Time Complexity of the below implementation is O(N) where N is the number of nodes in the Binary Tree and the Space Complexity is O((depth of binary tree * 2) – 1) in worst case.

## Python3

 `# Python program for the above approach``from` `queue ``import` `deque` `def` `topView(root):``    ``dic ``=` `{}` `    ``# variable which is going to store``    ``# the minimum positional value.``    ``mi ``=` `float``(``'inf'``)` `    ``if` `not` `root:``        ``return` `ret` `    ``q ``=` `deque([(root, ``0``)])` `    ``while` `q:``        ``cur ``=` `q.popleft()``        ``if` `cur[``1``] ``not` `in` `dic:``            ``dic[cur[``1``]] ``=` `cur[``0``].data``            ``mi ``=` `min``(mi, cur[``1``])``        ``if` `cur[``0``].left:``            ``q.append((cur[``0``].left, cur[``1``] ``-` `1``))``        ``if` `cur[``0``].right:``            ``q.append((cur[``0``].right, cur[``1``] ``+` `1``))` `    ``# Starting from the leftmost node and``    ``# just incrementing it until``    ``# the rightmost node stored in the dic.``    ``while` `mi ``in` `dic:``        ``print``(dic[mi], end``=``' '``)``        ``mi ``+``=` `1`  `class` `Node:``    ``def` `__init__(``self``, val):``        ``self``.data ``=` `val``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `Node(``1``)``    ``root.left ``=` `Node(``2``)``    ``root.right ``=` `Node(``3``)``    ``root.left.right ``=` `Node(``4``)``    ``root.left.right.right ``=` `Node(``5``)``    ``root.left.right.right.right ``=` `Node(``6``)``    ``print``(``"Top view of Binary Tree (from left to right) is as follows:"``)``    ``topView(root)``    ``# This code is contributed by Karthikayan Mailsamy.`
Output
```Top view of Binary Tree (from left to right) is as follows:
2 1 3 6 ```

Time Complexity: O(N)

My Personal Notes arrow_drop_up