# Top View Of The Tree

#### You are given a Binary Tree of integers. You are supposed to return the top view of the given binary tree. The Top view of the binary tree is the set of nodes that are visible when we see the tree from the top.

##### Example:

```
For the given binary tree:
```

```
The top view of the tree will be {10, 4, 2, 1, 3, 6}.
```

##### Input Format:

```
The first line contains an integer 'T' which denotes the number of test cases.
The first line of each test case contains elements of the tree in the level order form. The line consists of values of nodes separated by a single space. In case a node is null, we take -1 in its place.
```

##### Example:

```
The 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
```

##### 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)
1
2 3
4 -1 5 6
-1 7 -1 -1 -1 -1
-1 -1
```

##### Note :

```
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.
2. The input ends when all nodes at the last level are null(-1).
```

##### Output Format:

```
For each test case, return the vector/list of all the elements of the top view of the given tree.
```

##### Note :

```
You don't need to print the output, it has already been taken care of. Just implement the given function.
```

##### Constraints:

```
1 <= T <= 100
0 <= N <= 1000
0 <= data <= 10^6 and data != -1
Where ‘N’ is the total number of nodes in the binary tree, and 'data' is the value of the binary tree node.
Time limit: 1 sec
```

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.

The intuition is to find the breadth of the tree first so that we can beforehand know the maximum horizontal distance and a minimum horizontal distance of a node from the root node. We can use the absolute value of minimum horizontal distance as an offset. Now we can use an array/list 'visited' to store the visited nodes where ‘i’-th element will store the node at ('i' - 'offset') distance horizontally from the root node. This way we can reduce the time complexity of inserting and accessing the nodes.

Let us define a function:

```
getBreadth(TreeNode<int>* root, int hrDistance, int &minLeft,
int &maxRight)
```

Which finds the minimum horizontal distance and maximum horizontal distance and stores it in ‘minLeft’ and ‘rightLeft’ variables respectively. And ‘hrDistance’ stores the horizontal distance between the current node and the root node.

Now consider the following steps to implement this function:

- If ‘root’ is NULL then return.
- Otherwise
- Recur for left subtree i.e. getBreadth(root->left, hrDistance-1, ‘minLeft’, ‘maxRight’)
- Similarly recur for right subtree i.e. getBreadth(root->right, hrDistance+1, ‘minLeft', ‘maxRight’)
- Now update the ‘minLeft’ and 'maxRight' with the horizontal distance of the current node.
- ‘minLeft’ = min('minLeft', hrDistance)
- 'maxRight' = min('maxRight', hrDistance)

After getting the minimum horizontal distance and maximum horizontal distance, we can create an array/list ‘visited’ of ('maxRight' - ‘minLeft’ + 1) size to store the nodes. Also we can set the 'offset' to negative of minimum horizontal distance.

We will follow the same approach as mentioned in approach 2 to visit the nodes.

The steps are as follows:

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

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