987. Vertical Order Traversal of a Binary Tree

问题：

给定二叉树，

root坐标为(0,0)，

对于任意节点 (x,y), 其左孩子(x+1, y-1), 右孩子(x+1, y+1)

按照列输出节点。（从左到右，对于每一列，从上到下）

若多个节点坐标相同，则按照值从小到大进行输出。

Example 1:
Input: root = [3,9,20,null,null,15,7]
Output: [[9],[3,15],[20],[7]]
Explanation:
Column -1: Only node 9 is in this column.
Column 0: Nodes 3 and 15 are in this column in that order from top to bottom.
Column 1: Only node 20 is in this column.
Column 2: Only node 7 is in this column.

Example 2:
Input: root = [1,2,3,4,5,6,7]
Output: [[4],[2],[1,5,6],[3],[7]]
Explanation:
Column -2: Only node 4 is in this column.
Column -1: Only node 2 is in this column.
Column 0: Nodes 1, 5, and 6 are in this column.
          1 is at the top, so it comes first.
          5 and 6 are at the same position (2, 0), so we order them by their value, 5 before 6.
Column 1: Only node 3 is in this column.
Column 2: Only node 7 is in this column.

Example 3:
Input: root = [1,2,3,4,6,5,7]
Output: [[4],[2],[1,5,6],[3],[7]]
Explanation:
This case is the exact same as example 2, but with nodes 5 and 6 swapped.
Note that the solution remains the same since 5 and 6 are in the same location and should be ordered by their values.
 

Constraints:
The number of nodes in the tree is in the range [1, 1000].
0 <= Node.val <= 1000

　　

example 1:

 

 example 2:

 

 example 3:

 

 

 

解法：BFS DFS

思路：对二叉树使用BFS或DFS进行遍历，

构造node结构体：node[y][x]={node1, node2, node3...}

最后，遍历node，对于每一列

node[y]

从第一行开始x=0...

node[y][0]={node1，node2...}

将该同一坐标的节点，按照value输出。加入结果中。

        map<int, map<int, multiset<int>>> node;//{y,{x,{n1,n2,n3...}}}
        dfs(node, root, 0, 0);
        //bfs...
        for(auto n:node) {
            vector<int> col;
            for(auto nc:n.second) {
                col.insert(col.end(),nc.second.begin(),nc.second.end());
            }
            res.push_back(col);
        }

⚠️ 注意：node使用map：因为在遍历树之前，行数和列数都不确定，且需要按照从小到大存储。

对同一坐标，使用multiset：由于需要按照value大小输出，且，可能存在相同val的节点。

 

状态：

• TreeNode* root：当前节点
• (x, y)：坐标

BFS

代码参考：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        vector<vector<int>> res;
        map<int, map<int, multiset<int>>> node;
        queue<pair<TreeNode*, pair<int,int>>> q;
        q.push({root,{0,0}});//{node,{col,row}}//firstly sort by col
        while(!q.empty()) {
            int sz = q.size();
            for(int i=0; i<sz; i++) {
                auto [cur, ord] = q.front();
                auto [y, x] = ord;
                q.pop();
                node[y][x].insert(cur->val);//same(x,y) should sort by val
                if(cur->left) {
                    q.push({cur->left,{y-1, x+1}});
                }
                if(cur->right) {
                    q.push({cur->right,{y+1, x+1}});
                }
            }
        }
        for(auto n:node) {
            vector<int> col;
            for(auto nc:n.second) {
                col.insert(col.end(),nc.second.begin(),nc.second.end());
            }
            res.push_back(col);
        }
        return res;
    }
};

 

DFS

代码参考：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void dfs(map<int, map<int, multiset<int>>>& node, TreeNode* root, int x, int y) {
        if(!root) return;
        node[y][x].insert(root->val);
        if(root->left) dfs(node, root->left, x+1, y-1);
        if(root->right) dfs(node, root->right, x+1, y+1);
        return;
    }
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        vector<vector<int>> res;
        map<int, map<int, multiset<int>>> node;//{y,{x,{n1,n2,n3...}}}
        dfs(node, root, 0, 0);
        for(auto n:node) {
            vector<int> col;
            for(auto nc:n.second) {
                col.insert(col.end(),nc.second.begin(),nc.second.end());
            }
            res.push_back(col);
        }
        return res;
    }
};