# 987. Vertical-Order-Traversal-of-a-Binary-Tree

difficulty: Medium

&#x20;section pre{ background-color: #eee; border: 1px solid #ddd; padding:10px; border-radius: 5px; }&#x20;

Given a binary tree, return the *vertical order* traversal of its nodes values.

For each node at position `(X, Y)`, its left and right children respectively will be at positions `(X-1, Y-1)` and `(X+1, Y-1)`.

Running a vertical line from `X = -infinity` to `X = +infinity`, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing `Y` coordinates).

If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.

Return an list of non-empty reports in order of `X` coordinate.  Every report will have a list of values of nodes.

**Example 1:**

![](https://assets.leetcode.com/uploads/2019/01/31/1236_example_1.PNG)

```
Input: [3,9,20,null,null,15,7]
Output: [[9],[3,15],[20],[7]]
Explanation: 
Without loss of generality, we can assume the root node is at position (0, 0):
Then, the node with value 9 occurs at position (-1, -1);
The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
The node with value 20 occurs at position (1, -1);
The node with value 7 occurs at position (2, -2).
```

**Example 2:**

![](https://assets.leetcode.com/uploads/2019/01/31/tree2.png)

```
Input: [1,2,3,4,5,6,7]
Output: [[4],[2],[1,5,6],[3],[7]]
Explanation: 
The node with value 5 and the node with value 6 have the same position according to the given scheme.
However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.
```

**Note:**

1. The tree will have between 1 and `1000` nodes.
2. Each node's value will be between `0` and `1000`.

## Method One

```java
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * } 
 */
class Solution {
    public List<List<Integer>> verticalTraversal(TreeNode root) {
        //和314不一样的地方是，要新建一个 tempMap,然后扫里面全部的list.
        // BFS, easy to think about the order.
        // use an extra queue to record the x-coordinates.
        List<List<Integer>> ans = new ArrayList<>();
        if(root == null) {
            return ans;
        }

        Map<Integer, List<Integer>> ansMap = new HashMap<>();
        Queue<TreeNode> qNode = new LinkedList<>();
        Queue<Integer> qCol   = new LinkedList<>();

        int minCol = Integer.MAX_VALUE;
        int maxCol = Integer.MIN_VALUE;

        qNode.offer(root);
        qCol.offer(0);

        while(!qNode.isEmpty()) {
            int qSize = qNode.size();
            Map<Integer, List<Integer>> tempMap = new HashMap<>();
            while(qSize > 0) {
                TreeNode cur = qNode.poll();
                int col      = qCol.poll();

                tempMap.putIfAbsent(col, new ArrayList<Integer>());
                tempMap.get(col).add(cur.val);

                if(minCol > col) {
                    minCol = col;
                }
                if(maxCol < col) {
                    maxCol = col;
                }

                if(cur.left != null) {
                    qNode.offer(cur.left);
                    qCol.offer(col - 1);
                }
                if(cur.right != null) {
                    qNode.offer(cur.right);
                    qCol.offer(col + 1);
                }
                qSize--;
            }
            for(int col : tempMap.keySet()) {
                ansMap.putIfAbsent(col, new ArrayList<Integer>());
                List<Integer> list = tempMap.get(col);
                Collections.sort(list);
                ansMap.get(col).addAll(list);
            }
        }

        for(int i = minCol; i <= maxCol; i++ ) {
            ans.add(ansMap.get(i));
        }
        return ans;
    }
}
```
