[LC] 314. Binary Tree Vertical Order Traversal

Given a binary tree, return the vertical order traversal of its nodes' values. (ie, from top to bottom, column by column).

If two nodes are in the same row and column, the order should be from left to right.

Examples 1:

Input: [3,9,20,null,null,15,7]

   3
  /\
 /  \
 9  20
    /\
   /  \
  15   7 

Output:

[
  [9],
  [3,15],
  [20],
  [7]
]

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;
    public List<List<Integer>> verticalOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        dfs(root, 0);
        for (int i = min; i <= max; i++) {
            res.add(new ArrayList<>());
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        Queue<Integer> indexQ = new LinkedList<>();
        queue.offer(root);
        // map the leftmost to 0, so that root is -min
        indexQ.offer(-min);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            int curIndex = indexQ.poll();
            res.get(curIndex).add(cur.val);
            if (cur.left != null) {
                queue.offer(cur.left);
                indexQ.offer(curIndex - 1);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
                indexQ.offer(curIndex + 1);
            }
        }
        return res;
    }
    
    private void dfs(TreeNode root, int num) {
        if (root == null) {
            return;
        }
        min = Math.min(min, num);
        max = Math.max(max, num);
        dfs(root.left, num - 1);
        dfs(root.right, num + 1);
    }
    
}