Top View Of 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. 

The 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 call preOrder function. Here, ‘hDistance’ defines the horizontal distance and level defines the depth of the tree.

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

    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’.

The intuition is to use the level order traversal. Because while traversing in the tree level by level, the two or more than two nodes which have the same horizontal distance from the root node will be visible as the only one who will have a minimum level from the root node. So we do level order traversal so that the node which has the minimum level from the root node will visit before any other node of same horizontal distance below it. We will be using a Map to map the horizontal distance of the node from the root node with data of nodes. While traversing in level by level, if any horizontal distance is not visited yet then, we will store the value of that node corresponding to current horizontal distance. And our queue for traversing in level order will be storing two things; one will be the node, and other will be the horizontal distance of that node from the root node so that while changing the level, we can get the horizontal distance of children nodes from their parent nodes. 

The steps are as follows:

1. Make a Map like:
   • map<int, int> visited, where the key of ‘visited’ is the horizontal distance and value corresponding to that key is the value of the node at that horizontal distance.
2. Make a queue for traversing level by level like :
   • queue< pair< TreeNode<int>*, int> > level, where the first element of the ‘level’ is the node and the second element of the ‘level’ is the horizontal distance of that node from the root node.
3. Push the root node into the queue say ‘level’ and make the horizontal distance 0 with the root node.
4. Iterate until ‘level’ does not become empty:
   • Each time get the current node from the front of the ‘level’ let’s say ‘currNode’. And get the horizontal distance of that node, let’s say ‘hrDistance’. Check if ‘hrDistance’ is already visited or not? If it is not visited yet then make it visited with the value of ‘currNode’ else ignore it because the previous node must have visited before the current node and its level will be less then current, so the previously-stored node will hide the current node.
   • If the left node exists of ‘currNode’, then append the left node to the queue with one less horizontal distance than the ‘curNode’.

       level.push({currNode->left,  hrDistance-1 }).

• If the right node exists of ‘curr’, then append the right node to the queue with one more horizontal distance than the ‘curr’.

       level.push({currNode->right, hrDistance+1 }).

    5.  Finally, our values of ‘visited’ have all the nodes which can be viewed from the top of the tree. Store them and return the final answer.