Formatted question description: https://leetcode.ca/all/987.html

987. Vertical Order Traversal of a Binary Tree (Medium)

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:

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:

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.

 

Related Topics:
Hash Table, Tree

Solution 1.

Use a map<int, map<int, multiset<int>>> m to store the values – m[node->x][node->y].insert(node->val). (Using set instead of multiset can also pass this problem. I guess LeetCode uses the node values as IDs and assumes the uniqueness of the values. I used multiset here to be safe.)

In this way, the values are sorted first in asending order of the x values, then in asending order of y values, then in asending order of node values.

Note that we shouldn’t sort the values with the same X values all together, we should only sort them if they have the same position, i.e. when both their x and y values are equal.

// OJ: https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/

// Time: O(NlogN)
// Space: O(N)
class Solution {
    map<int, map<int, multiset<int>>> m;
    void dfs(TreeNode *root, int x, int y) {
        if (!root) return;
        m[x][y].insert(root->val);
        dfs(root->left, x - 1, y + 1);
        dfs(root->right, x + 1, y + 1);
    }
public:
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        dfs(root, 0, 0);
        vector<vector<int>> ans;
        for (auto &[x, mm] : m) {
            ans.emplace_back();
            for (auto &[y, vals] : mm) {
                for (int n : vals) ans.back().push_back(n);
            }
        }
        return ans;
    }
};

Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> verticalTraversal(TreeNode root) {
        List<List<Integer>> verticalTraversal = new ArrayList<List<Integer>>();
        if (root == null)
            return verticalTraversal;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        Queue<Struct> structQueue = new LinkedList<Struct>();
        queue.offer(root);
        Struct rootStruct = new Struct(0, 0, root.val);
        structQueue.offer(rootStruct);
        List<Struct> structList = new ArrayList<Struct>();
        structList.add(rootStruct);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            Struct nodeStruct = structQueue.poll();
            int position = nodeStruct.getPosition();
            int depth = nodeStruct.getDepth();
            TreeNode left = node.left;
            TreeNode right = node.right;
            if (left != null) {
                queue.offer(left);
                Struct leftStruct = new Struct(position - 1, depth + 1, left.val);
                structQueue.offer(leftStruct);
                structList.add(leftStruct);
            }
            if (right != null) {
                queue.offer(right);
                Struct rightStruct = new Struct(position + 1, depth + 1, right.val);
                structQueue.offer(rightStruct);
                structList.add(rightStruct);
            }
        }
        Collections.sort(structList);
        int size = structList.size();
        int index = 0;
        int prevPosition = Integer.MAX_VALUE;
        while (index < size) {
            Struct struct = structList.get(index);
            int position = struct.getPosition();
            if (position == prevPosition) {
                int totalSize = verticalTraversal.size();
                List<Integer> previousList = verticalTraversal.remove(totalSize - 1);
                previousList.add(struct.getValue());
                verticalTraversal.add(previousList);
            } else {
                List<Integer> currentList = new ArrayList<Integer>();
                currentList.add(struct.getValue());
                verticalTraversal.add(currentList);
            }
            prevPosition = position;
            index++;
        }
        return verticalTraversal;
    }
}

class Struct implements Comparable<Struct> {
	private int position;
    private int depth;
	private int value;

	public Struct() {
		
	}

	public Struct(int position, int depth, int value) {
		this.position = position;
        this.depth = depth;
		this.value = value;
	}

	public int compareTo(Struct struct2) {
		if (this.position != struct2.position)
			return this.position - struct2.position;
		else if (this.depth != struct2.depth)
			return this.depth - struct2.depth;
        else
            return this.value - struct2.value;
	}

	public int getPosition() {
		return position;
	}

    public int getDepth() {
        return depth;
    }

    public int getValue() {
		return value;
	}
}

All Problems

All Solutions