这道题自己一开始想偏了(或许也不算是),想用的前序遍历来处理,但是苦于一时想不出,如何保存column的值,而且最后也不好处理map的column从小到大的遍历。
现在是参考点击打开链接,采用层级遍历,这样保证存到List<Integer>的值都是顺序的。当中有两点精妙的地方:
1. 定义了一个column的queue,这个column和queue中的treenode是一一对应的,这个column可以当做key去map中索引,当然这个也可以用一个class来定义,
2. 定义了column的min和max,最后map的遍历从min到max,就能保证有序,这个很赞。
/**
* 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/*TreeNode.val*/>> result = new LinkedList<>();
if (root == null) {
return result;
}
Map<Integer/*column*/, List<Integer/*TreeNode.val*/>> map = new HashMap<>();
Queue<Integer/*column*/> cols = new LinkedList<>();
Queue<TreeNode> nodeQueue = new LinkedList<>();
int min = 0, max = 0;
nodeQueue.offer(root);
cols.offer(0);
while (!nodeQueue.isEmpty()) {
TreeNode node = nodeQueue.poll();
int column = cols.poll();
if (!map.containsKey(column)) {
List<Integer/*TreeNode.val*/> list = new LinkedList<>();
list.add(node.val);
map.put(column, list);
} else {
map.get(column).add(node.val);
}
if (node.left != null) {
nodeQueue.offer(node.left);
cols.offer(column - 1);
if (min > column - 1) {
min = column - 1;
}
}
if (node.right != null) {
nodeQueue.offer(node.right);
cols.offer(column + 1);
if (max < column + 1) {
max = column + 1;
}
}
}
for (int i = min; i <= max; i++) {
result.add(map.get(i));
}
return result;
// List<List<Integer/*TreeNode.val*/>> result = new List<>();
// if (root == null) {
// return result;
// }
// Map<Integer/*column*/, List<Integer/*TreeNode.val*/>> map = new HashMap<>();
// Stack<TreeNode> stack = new Stack<>();
// stack.push(root);
// int column = 0;
// while (!stack.isEmpty()) {
// TreeNode node = stack.pop();
// if (node.right != null) {
// stack.push(node.right);
// if (map.get(column + 1)) {
// }
// }
// if (node.left != null) {
// stack.push(node);
// node = node.left;
// stack.push(node);
// } else {
// }
// }
}
}