Last Updated: 17 Dec, 2021

Vertical Order Traversal of Binary Tree

Hard
Asked in company
Zeta

Problem statement

You are given a binary tree having 'n' nodes.


Vertical order traversal is a traversal in which we traverse the nodes from left to right and then from top to bottom.


In the case of multiple nodes in the same place, we traverse them in the non-decreasing order of their value.


Formally, assume for any node at position (x, y), its left child will be at the position (x - 1, y + 1), and the right child at position (x + 1, y + 1). Assume the root is at coordinate (0, 0).


Run vertical lines from 'x' = -infinity to 'x' = +infinity. Now whenever this vertical line touches some nodes, we need to add those values of the nodes in order starting from top to bottom with the decreasing 'y' coordinates.


If multiple nodes have the same 'x' and 'y' coordinates, they will be accessed in non-decreasing order of values.


Find the vertical order traversal of the given tree.


Example :
Input: Let the binary tree be:

alt text

Output: [2, 7, 5, 2, 6, 5, 4, 11, 9]

Explanation: The nodes having the same 'x' coordinates are:

'x' = -2 : [2]
'x' = -1 : [7, 5]
'x' = 0 : [2, 6]
'x' = 1 : [5, 4, 11]
'x' = 2 : [9]

Here 4 and 11 have the same 'x' and 'y' coordinates. So they are considered in non-decreasing order.
Input Format:
The first line contains elements 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. So -1 would not be a part of the tree nodes.
Input format explanation:
The level order input for the tree depicted in the below image would be 

alt text

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


Output Format:
Print the vertical order traversal of the given binary tree.


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

Approaches

01 Approach

We have to store the values at each coordinate (x, y). So we can use an ordered map for the same. We can use a map of map of container to store the values at each coordinate.

Since we need the values in non-decreasing order, we can use a min heap(priority queue). Please note that there are other ways to implement this.

The steps are as follows:

List verticalOrderTraversal(TreeNode 'root')

  1. Create a map of map of min-heap 'coord'.
  2. Implement level order traversal on the tree using a queue 'q'.
  3. In the queue 'q', we’ll store the TreeNode and the coordinates (x, y).
  4. For each node 'curr' in the tree:
    • Add curr->data in coord[x][y].
  5. Let 'ans' be a list.
  6. For each 'x' coordinate in increasing order:
    • For each 'y' coordinate in coord[x] in increasing order:
      • Add all the elements present in coord[x][y] in 'ans'. Since coord[x][y] is a min-heap, the elements inserted in 'ans' are in sorted order.
  7. Return 'ans'.