Print Nodes in Top View of Binary Tree

23 Jun, 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 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. 
       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. 
Implementation:
C++14
Java
Python3
C#
Javascript
// C++ program to print top// view of binary tree #include <bits/stdc++.h>using namespace std; // Structure of binary treestruct Node{    Node* left;    Node* right;    int hd;    int data;}; // function to create a new nodeNode* 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 treevoid topview(Node* root){    if (root == NULL)        return;    queue<Node*> 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 functionsint 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 program to print top// view of binary treeimport java.util.LinkedList;import java.util.Map;import java.util.Map.Entry;import java.util.Queue;import java.util.TreeMap; // class to create a nodeclass Node {    int data;    Node left, right;     public Node(int data)    {        this.data = data;        left = right = null;    }} // class of binary treeclass 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<QueueObj> q = new LinkedList<QueueObj>();        Map<Integer, Node> topViewMap            = new TreeMap<Integer, Node>();         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 (Map.Entry<Integer, Node> 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 program to print top# view of binary tree # Binary Tree Node""" utility that allocates a newNodewith 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 Codeif __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# program to print top// view of binary treeusing System;using System.Collections;using System.Collections.Generic; // Class to create a nodeclass 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 treeclass 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
<script>// Javascript program to print top// view of binary tree class Node{    constructor(data)    {        this.data=data;        this.left = this.right = null;        this.hd = 0;    }} // Driver Codefunction topview(root){    if(root == null)        return;    let q = [];    let m = new Map();    let hd = 0;    root.hd = hd;    q.push(root);         while(q.length!=0)    {        root = q[0];        hd = root.hd;        if(!m.has(hd))            m.set(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.shift()    }         let arr = Array.from(m);    arr.sort(function(a,b){return a[0]-b[0];})         for (let [key, value] of arr.values())    {        document.write(value+" ");    }} let root = new Node(1)root.left = new Node(2)root.right = new Node(3)root.left.right = new Node(4)root.left.right.right = new Node(5)root.left.right.right.right = new Node(6)document.write("Following are nodes in top",      "view of Binary Tree<br>")topview(root) // This code is contributed by avanitrachhadiya2155</script>
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
default, selected
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Following are nodes in top view of Binary Tree
The top view of the tree is : 
2 1 3 6 
Time complexity : O(n) Auxiliary Space : O(n)
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.
Implementation:
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; // Structure of binary treestruct Node {    Node* left;    Node* right;    int data;}; // function to create a new nodeNode* newNode(int key){    Node* node = new Node();    node->left = node->right = NULL;    node->data = key;    return node;} // function to fill the mapvoid 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 treevoid 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 functionsint 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 program to print top// view of binary treeimport 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<Integer, pair> 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<Integer, pair> 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
# Binary Tree Node""" utility that allocates a newNodewith 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 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("Following are nodes in top view of Binary Tree")topView(root) # This code is contributed by SHUBHAMSINGH10
// C# program to print top// view of binary treeusing 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
<script>// Javascript program to print top// view of binary tree // Structure of binary treeclass Node{    constructor()    {        this.data = 0;        this.left = this.right = null;    }} class pair{    constructor(i, j)    {        this.first = i;        this.second = j;    }} // map to store the pair of node value and    // its level with respect to the vertical    // distance from root.let m = new Map();     // function to create a new node   function newNode(key){    let node = new Node();        node.left = node.right = null;        node.data = key;        return node;} // function to fill the mapfunction fillMap(root, d, l){    if (root == null)            return;          if (m.get(d) == null) {            m.set(d, new pair(root.data, l));        }        else if (m.get(d).second > l) {            m.set(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 treefunction topView(root){    fillMap(root, 0, 0);          let arr=Array.from(m.keys());         arr.sort(function(a,b){return a-b;});        for (let key of arr.values()) {            document.write(m.get(key).first + " ");        }} // Driver Codelet 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("Following are nodes in"                   + " top view of Binary Tree<br>");topView(root); // This code is contributed by rag2127</script>
Following are nodes in top view of Binary Tree
2 1 3 6 
Time complexity : O(nlogn) Auxiliary Space : O(n)
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:
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.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.In this approach, no map is used.
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.
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.
In this approach, no map is used.
Implementation:
C++14
// C++ Program to print Top View of a binary Tree #include <iostream>#include <queue>#include <stack>using namespace std; // class for Tree nodeclass 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 Treeclass Tree {public:    Node* root;    Tree() { root = 0; }     void topView()    {        // queue for holding nodes and their horizontal        // distance from the root node        queue<pair<Node*, int> > q;         // pushing root node with distance 0        q.push(make_pair(root, 0));         // hd is current node's horizontal distance from        // root node l is current left min horizontal        // distance (or max in magnitude) so far from the        // root node r is current 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 codeint 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;}
2 1 3 6 
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.
This article is contributed by Rohan. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
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. 
Implementation:
Python3
# Python program for the above approachfrom 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 Codeif __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.
Top view of Binary Tree (from left to right) is as follows:
2 1 3 6 
Time Complexity: O(N)
Space complexity: O(N) for queue
Aarsee
AdarshKL
Md.Shahazad Uddin
SHUBHAMSINGH10
akashdebnath
andrew1234
rutvik_56
pratham76
mjustboring
karthikayanmailsamy
avanitrachhadiya2155
rag2127
Kirti_Mangal
ce20b112
deadvikash
guptaishan
noviced3vq6
hardikkoriintern
Amazon
BFS
Paytm
Samsung
tree-view
Walmart
Hash
Queue
Tree
Paytm
Amazon
Samsung
Walmart
Hash
Queue
Tree
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
What is Hashing | A Complete Tutorial
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Count pairs with given sum
Breadth First Search or BFS for a Graph
Queue in Python
Queue Interface In Java
Introduction to Data Structures
Queue using Stacks