Code360 powered by Coding Ninjas X Naukri.com. Code360 powered by Coding
Ninjas X Naukri.com

Last Updated: 19 Oct, 2020

Moderate

```
Input: Let the binary tree be:
```

```
Output: [10, 4, 2, 1, 3, 6]
Explanation: Consider the vertical lines in the figure. The top view contains the topmost node from each vertical line.
```

```
The first line of input contains elements in the level order form for the first binary tree. The line consists of values of nodes separated by a single space. In case a node is null, we take -1 in its place.
```

```
The level order input for the tree depicted in the below image would be
```

```
1
2 3
4 -1 5 6
-1 7 -1 -1 -1 -1
-1 -1
The sequence will be put together in a single line separated by a single space. Hence, for the above-depicted tree, the input will be given as:
1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1
Explanation :
Level 1 :
The root node of the tree is 1
Level 2 :
Left child of 1 = 2
Right child of 1 = 3
Level 3 :
Left child of 2 = 4
Right child of 2 = null (-1)
Left child of 3 = 5
Right child of 3 = 6
Level 4 :
Left child of 4 = null (-1)
Right child of 4 = 7
Left child of 5 = null (-1)
Right child of 5 = null (-1)
Left child of 6 = null (-1)
Right child of 6 = null (-1)
Level 5 :
Left child of 7 = null (-1)
Right child of 7 = null (-1)
The first not-null node (of the previous level) is treated as the parent of the first two nodes of the current level. The second not-null node (of the previous level) is treated as the parent node for the next two nodes of the current level, and so on.
The input ends when all nodes at the last level are null (-1).
```

```
Print the vector/list of all the elements of the top view of the given tree from left to right.
```

```
You do not need to print anything; it has already been taken care of. Just implement the given function.
```

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:

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

- 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:

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

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

- Push the root node into the queue say ‘level’ and make the horizontal distance 0 with the root node.
- 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.

Similar problems

Preorder Traversal

Easy

Posted: 18 Jan, 2022

Preorder Traversal

Easy

Posted: 18 Jan, 2022

Inorder Traversal

Easy

Posted: 19 Jan, 2022

Inorder Traversal

Easy

Posted: 19 Jan, 2022

Inorder Traversal

Easy

Posted: 19 Jan, 2022

Inorder Traversal

Easy

Posted: 19 Jan, 2022

Postorder Traversal

Easy

Posted: 20 Jan, 2022

Postorder Traversal

Easy

Posted: 20 Jan, 2022

Height of Binary Tree

Easy

Posted: 22 Apr, 2022

Height of Binary Tree

Easy

Posted: 22 Apr, 2022

Height of Binary Tree

Easy

Posted: 22 Apr, 2022

Locked Binary Tree

Easy

Posted: 12 May, 2022