【Leetcode】314. Binary Tree Vertical Order Traversal

题目地址：

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

给定一个二叉树，将其每一列的节点按照从上到下从左到右的顺序存成一个列表返回。

法1：DFS。设某个节点是从根向左总共走$l$步并且向右总共走$r$步到达的，那么两个节点在同一列，当且仅当这两个节点对应的$r-l$相等。所以在深搜的时候，可以用一个map，key存$r-l$，value存对应列的树的节点和深度。由于深搜的时候同一列哪个节点在左边哪个在右边是可以维持的，因为可以先DFS左子树再右子树，这样加入TreeNode的时候右边的会排在左边的后面，但是，DFS没法判断同一列的两个节点哪个在上哪个在下，这就是为什么要记录节点的深度，最终要把map里的每个vector按照深度排序后最后再加入最终结果（由于C++里对对象的排序是不稳定的，所以要用std::stable_sort）。代码如下：

/**
 * 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:
  using PTI = pair<TreeNode*, int>;
  vector<vector<int>> verticalOrder(TreeNode* root) {
    vector<vector<int>> res;
    map<int, vector<PTI>> mp;
    dfs(root, 0, 0, 0, mp);
    for (auto& [k, v] : mp) {
      stable_sort(v.begin(), v.end(),
           [&](auto& t1, auto& t2) { return t1.second < t2.second; });
      res.push_back({});
      for (auto p : v) res.back().push_back(p.first->val);
    }

    return res;
  }

  void dfs(TreeNode* p, int l, int r, int dep, map<int, vector<PTI>>& mp) {
    if (!p) return;
    mp[r - l].push_back({p, dep});
    dfs(p->left, l + 1, r, dep + 1, mp);
    dfs(p->right, l, r + 1, dep + 1, mp);
  }
};

时间复杂度$O(nh\log h)$（最多一共有$n$列，每列最多$h$个数字，排序需要$O(h\log h)$），空间复杂度$O(n)$。

法2：BFS。BFS可以有效解决两个节点谁在上谁在下，和谁在左谁在右的问题，但没法判断两个节点是否在同一列。可以新开一个类，里面存树的节点和它在的列，然后用一个map以列为key，该列的节点的val为值，最后将这个map遍历一遍加入最终结果即可。代码如下：

/**
 * 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:
  using PTI = pair<TreeNode*, int>;
  vector<vector<int>> verticalOrder(TreeNode* root) {
    vector<vector<int>> res;
    if (!root) return res;

    map<int, vector<int>> mp;
    queue<PTI> q;
    q.push({root, 0});
    while (q.size()) {
      auto p = q.front(); q.pop();
      auto* t = p.first;
      mp[p.second].push_back(t->val);
      if (t->left) q.push({t->left, p.second - 1});
      if (t->right) q.push({t->right, p.second + 1});
    }
    for (auto& [k, v] : mp) res.push_back(v);
    return res;
  }
};

时空复杂度$O(n\log n)$。