Leetcode: 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:
Given binary tree [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its vertical order traversal as:
[
  [9],
  [3,15],
  [20],
  [7]
]
Given binary tree [3,9,20,4,5,2,7],
    _3_
   /   \
  9    20
 / \   / \
4   5 2   7
return its vertical order traversal as:
[
  [4],
  [9],
  [3,5,2],
  [20],
  [7]
]

二叉树Vertical order traversal。这道题意思很简单但例子举得不够好，假如上面第二个例子里5还有右子树的话，就会和20在一条column里。总的来说就是假定一个node的column是 i，那么它的左子树column就是i - 1，右子树column就是i + 1。

知道这样就好办了，我们维护一个HashMap<Integer, List<Integer>>, key是column编号，List是在该column的各个TreeNode的value，然后level order traversal, 把相应的node value加到相应的key去。我们不关心具体column编号所以取root为0列就好了，其他以此为基准。

本题取巧的地方在于如何获得column编号，我们这里是再用了一个queue, 同步进行BFS；其他的做法可以做一个内部类

private class TreeColumnNode{
        public TreeNode treeNode;
        int col;
        public TreeColumnNode(TreeNode node, int col) {
            this.treeNode = node;
            this.col = col;
        }

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> verticalOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null) return res;
        HashMap<Integer, ArrayList<Integer>> map = new HashMap<Integer, ArrayList<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        LinkedList<Integer> colQue = new LinkedList<Integer>();
        queue.offer(root);
        colQue.offer(0);
        map.put(0, new ArrayList<Integer>());
        map.get(0).add(root.val);
        int min=0, max=0;
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            int col = colQue.poll();
            if (cur.left != null) {
                queue.offer(cur.left);
                colQue.offer(col-1);
                if (!map.containsKey(col-1)) {
                    map.put(col-1, new ArrayList<Integer>());
                }
                map.get(col-1).add(cur.left.val);
                if (col-1 < min) min = col - 1;
            }
            if (cur.right != null) {
                queue.offer(cur.right);
                colQue.offer(col+1);
                if (!map.containsKey(col+1)) {
                    map.put(col+1, new ArrayList<Integer>());
                }
                map.get(col+1).add(cur.right.val);
                if (col+1 > max) max = col + 1;
            }
        }
        for (int k=min; k<=max; k++) {
            if (map.containsKey(k))
                res.add(new ArrayList<Integer>(map.get(k)));
        }
        return res;
    }
}