Top View of the Binary Tree

As we know that all three traversals, i.e. pre-order, in-order and post-order, visit the tree node at once. We can use any of them. Here we are going to use pre-order traversal for the explanation. So while traversing in the pre-order traversal, we will keep track of horizontal distance of the node which is going to be visited from the root node, and we also keep track of the vertical level of that node (where the vertical level of root node would be ‘0’ and its children would be ‘1’ and so on.... ). We will be using the Map which stores the horizontal distance of the node from the root as the key and value in the map maintains a pair of containing the value of the node and the level of the node. Steps are as follows:

1. Make a Map like:
   • map <int, pair<int, int> > visited, where the key of “visited” defines the horizontal distance and value in the map maintains a pair of containing the value of the node and the level of the node.
2. And now apply for a pre-order.

applyPreorder(root , hDistance, level,visited) = { applyPreorder(root->left , hDistance-1, level+1,visited) , applyPreorder(root->right , hDistance+1, level+1,visited )}

Where ‘hDistance’ defines the horizontal distance and level defines the depth of the tree.

    3. For every ‘hDistance’ check whether it is visited or not? If it is not visited, then make it visited with the value of node and “level” and if it is already visited, then check if the previous stored “level” is greater than then the current level. If yes, then store the current node because the previous node now is hidden by the current node because the current node has a lesser height.

     4. Once we are done with pre-order, our map contains “hDistance” as the key and value corresponding to each “hDistance” stores the pair of nodes and their level that are visible from the top of the tree at that “hDistance”. So iterate over the map and store the value of the node in array/list. Let’s say “topView”.

    5. Return the “topView”.

O(N* log( N ) ), Where ‘N’ is the number of nodes in the given binary tree.

Since we are traversing at every node and storing the horizontal distance of every node into Map, So inserting an element into the map will take O(log N) time, and in the worst case (Skewed Trees) there will be ‘N’ distinct horizontal distance so it will take O(N * log(N)). While for ‘N’ element push and pop operation take O(1) time for the queue and also inserting and searching into the HashMap take O(1) time. So overall time complexity will be O(N*log(N)).

O(N), Where ‘N’ is the number of nodes in the given binary tree.

We are storing the top view of the tree. So in the worst case (Skewed Trees), all nodes of the given tree will be the top view elements, so, there will be ‘N’ distinct horizontal distance to be stored and also in that case stack size for recursion will be O(N). So overall space complexity will be O(N).