Print Nodes in Top View of Binary Tree

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. Expected time complexity is O(n)

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.



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print top
// view of binary tree
  
#include <iostream> 
#include<queue> 
#include<map>
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<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 functions
int main()
{
    /* Create following Binary Tree 
            
        / \ 
        2 3 
        
            
            
            
            
                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 */

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print top
// view of binary tree
import java.util.Queue;
import java.util.TreeMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
  
// 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<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 (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 
            
        / \ 
        2 3 
        
            
            
            
            
                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); 
    
      
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 
            
        / \ 
        2 3 
        
            
            
            
            
                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)

chevron_right