Top View of a Binary Tree

Binary Tree:

There can be a maximum of two children for each parent in a binary tree, which is a non-linear data structure of the tree type.

Every node in a binary tree has a left and right reference in addition to the data element. The node at the top of a tree's hierarchy is known as the root node. The nodes that contain other sub-nodes are the parent nodes.

The left and right children are the two children of a parent node. Hashing, data compression, network traffic routing, setting up binary heaps, and building binary search trees are just a few of the uses for a binary tree.

Top View:

Nodes in a binary tree are connected to one another in such a way that each node can have a maximum of two children.

Top view nodes are those that can be seen when looking down from above. We can print the nodes in any order in order to print the binary tree's top view.

A binary tree's top view is the collection of nodes that can be seen when the tree is seen from the top. For the tree depicted below

Example:

       1
     /   \
   2      3
  /  \     /  \
4    5   6   7

4 2 1 3 7 will appear at the top. Therefore, the top view will be: 4 2 1 3 7.

Approach

The strategy is to traverse the tree using the preorder traversal, check that the current vertical level has been visited, and if so, search for the smaller horizontal level node and store it. If not, we may simply update the visited vertical level and store the current node's node and horizontal level.

Since the map will show the node's horizontal distance from the root node, we can use it to determine if the horizontal level has been reached or not. Where key stands for the horizontal distance and value is the pair made up of each node's value and level,

Preorder traversal will be used to navigate the tree.

The value and level for this horizontal distance are updated each time we determine whether the level of the current horizontal distance is less than the highest level previously observed.

To obtain the vertical level, we must pass level 1 for the left child and level +1 for the right child.

In the map, print the values that are there.

C++ Program:

class Solution
{
    public:
    // Function that returns a list of the nodes in a binary tree that are visible in the top view, from left to right.
    vector<int> topView(Node *root)
    {
      vector<int>ans;
      if(root==NULL) return ans;
      
      map<int,int>m;
      queue<pair<Node*,int>> q;
      q.push(make_pair(root,0));
      while(!q.empty()){
          pair<Node*,int>temp=q.front();
          q.pop();
          
         Node*frontnode=temp.first;
         int hd=temp.second;
         
         if(m.find(hd)==m.end()){
             m[hd]=frontnode->data;
         }
         
         if(frontnode->left){
             q.push(make_pair(frontnode->left,hd-1));
         }
          
          if(frontnode->right){
              q.push(make_pair(frontnode->right,hd+1));
          }
          
          }
          for(auto i:m){
              ans.push_back(i.second);
          }
          return ans;
    }

};

Input:
      1
   /    \
  2      3
Output: 
2 1 3

Java Program:

/*
class Node{
    int data;
    Node left;
    Node right;
    Node(int data){
        this.data = data;
        left=null;
        right=null;
    }
}
*/

class Solution
{
    // Function that returns a list of the nodes in a binary tree that are visible in the top view, from left to right.
    static ArrayList<Integer> topView(Node root)
    {
        Queue<Pair> q = new ArrayDeque<>();
        Map<Integer,Integer> map = new TreeMap<>();
        
        q.add(new Pair(0,root));
        
        while(!q.isEmpty()){
            
            Pair cur = q.poll();
            
            if(!map.containsKey(cur.hc)){
                map.put(cur.hc,cur.node.data);
            }
            
            if(cur.node.left!=null){
                q.add(new Pair(cur.hc-1,cur.node.left));
            }
            if(cur.node.right!=null){
                q.add(new Pair(cur.hc+1,cur.node.right));
            }
            
        }
        
        ArrayList<Integer> al = new ArrayList<Integer>();
        
        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            al.add(entry.getValue());
        }
        
        return al;
        
    }
    
    public static class Pair{
        int hc;
        Node node;
        
        public Pair(int hc,Node node){
            this.hc=hc;
            this.node=node;
        }
    }
}

Output:

Input:
      1
   /    \
  2      3
Output: 
2 1 3

Python Program:

from collections import deque
# Tree Node
# class Node:
#     def __init__(self, val):
#         self.right = None
#         self.data = val
#         self.left = None

class Solution:
    
    #Function that returns a list of the nodes in a binary tree that are visible in the top view, from left to right.
    def topView(self,root):
        q = deque()
        q.append((root, 0))
        d = {}
        while q:
            node, num = q.popleft()
            d[num] = d.get(num, node.data)
            if node.left:
                q.append((node.left, num-1))
            if node.right:
                q.append((node.right, num+1))
                
        ans = []
        for i in sorted(list(d.keys())):
            ans.append(d[i])
            
        return ans

Output:

Input:
      1
   /    \
  2      3
Output: 
2 1 3

Time Complexity: O(N), where N is the array's size, is the time complexity.

Space complexity: O(1)

How do you find the top view of a tree?

In order to discover it recursively while storing the horizontal distance between each node and the root node, we must first identify the nodes that are visible from the top.

A treetop view consists of the nodes that may be seen when a tree is viewed from the top.

Next TopicTypes of Binary Trees

← prev next →