【每日算法】 二叉树的垂序遍历的两种方式 :「DFS + 哈希表 + 排序」&「DFS + 优先队列（堆）」 ｜Python 主题月

输入：root = [3,9,20,null,null,15,7]
输出：[[9],[3,15],[20],[7]]
解释：
列 -1 ：只有结点 9 在此列中。
列  0 ：只有结点 3 和 15 在此列中，按从上到下顺序。
列  1 ：只有结点 20 在此列中。
列  2 ：只有结点 7 在此列中。
复制代码

输入：root = [1,2,3,4,5,6,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
列 -2 ：只有结点 4 在此列中。
列 -1 ：只有结点 2 在此列中。
列  0 ：结点 1 、5 和 6 都在此列中。
          1 在上面，所以它出现在前面。
          5 和 6 位置都是 (2, 0) ，所以按值从小到大排序，5 在 6 的前面。
列  1 ：只有结点 3 在此列中。
列  2 ：只有结点 7 在此列中。
复制代码

输入：root = [1,2,3,4,6,5,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
这个示例实际上与示例 2 完全相同，只是结点 5 和 6 在树中的位置发生了交换。
因为 5 和 6 的位置仍然相同，所以答案保持不变，仍然按值从小到大排序。
复制代码

class Solution {
    Map<TreeNode, int[]> map = new HashMap<>(); // col, row, val
    public List<List<Integer>> verticalTraversal(TreeNode root) {
        map.put(root, new int[]{0, 0, root.val});
        dfs(root);
        List<int[]> list = new ArrayList<>(map.values());
        Collections.sort(list, (a, b)->{
            if (a[0] != b[0]) return a[0] - b[0];
            if (a[1] != b[1]) return a[1] - b[1];
            return a[2] - b[2];
        });
        int n = list.size();
        List<List<Integer>> ans = new ArrayList<>();
        for (int i = 0; i < n; ) {
            int j = i;
            List<Integer> tmp = new ArrayList<>();
            while (j < n && list.get(j)[0] == list.get(i)[0]) tmp.add(list.get(j++)[2]);
            ans.add(tmp);
            i = j;
        }
        return ans;
    }
    void dfs(TreeNode root) {
        if (root == null) return ;
        int[] info = map.get(root);
        int col = info[0], row = info[1], val = info[2];
        if (root.left != null) {
            map.put(root.left, new int[]{col - 1, row + 1, root.left.val});
            dfs(root.left);
        }
        if (root.right != null) {
            map.put(root.right, new int[]{col + 1, row + 1, root.right.val});
            dfs(root.right);
        }
    }
}
复制代码

class Solution:
    def verticalTraversal(self, root: TreeNode) -> List[List[int]]:
        def dfs(node):
            if not node:
                return
            col, row, val = hashmap[node]
            if node.left:
                hashmap[node.left] = [col - 1, row + 1, node.left.val]
                dfs(node.left)
            if node.right:
                hashmap[node.right] = [col + 1, row + 1, node.right.val]
                dfs(node.right)
        hashmap = dict() # col, row, val
        hashmap[root] = [0, 0, root.val]
        dfs(root)
        lt = sorted(hashmap.values()) # 等价于加上key=lambda x:(x[0], x[1], x[2])
        n = len(lt)
        ans = []
        i = 0
        while i < n:
            j = i
            tmp = []
            while j < n and lt[j][0] == lt[i][0]:
                tmp.append(lt[j][2])
                j += 1
            ans.append(tmp)
            i = j
        return ans
复制代码

class Solution {
    PriorityQueue<int[]> q = new PriorityQueue<>((a, b)->{ // col, row, val
        if (a[0] != b[0]) return a[0] - b[0];
        if (a[1] != b[1]) return a[1] - b[1];
        return a[2] - b[2];
    });
    public List<List<Integer>> verticalTraversal(TreeNode root) {
        int[] info = new int[]{0, 0, root.val};
        q.add(info);
        dfs(root, info);
        List<List<Integer>> ans = new ArrayList<>();
        while (!q.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            int[] poll = q.peek();
            while (!q.isEmpty() && q.peek()[0] == poll[0]) tmp.add(q.poll()[2]);
            ans.add(tmp);
        }
        return ans;
    }
    void dfs(TreeNode root, int[] fa) {
        if (root.left != null) {
            int[] linfo = new int[]{fa[0] - 1, fa[1] + 1, root.left.val};
            q.add(linfo);
            dfs(root.left, linfo);
        }
        if (root.right != null) {
            int[] rinfo = new int[]{fa[0] + 1, fa[1] + 1, root.right.val};
            q.add(rinfo);
            dfs(root.right, rinfo);
        }
    }
}
复制代码

class Solution:
    def verticalTraversal(self, root: TreeNode) -> List[List[int]]:
        def dfs(node, fa):
            if node.left:
                linfo = (fa[0]-1,fa[1]+1,node.left.val)
                heapq.heappush(q, linfo)
                dfs(node.left, linfo)
            if node.right:
                rinfo = (fa[0]+1,fa[1]+1,node.right.val)
                heapq.heappush(q, rinfo)
                dfs(node.right, rinfo)
        info = (0, 0, root.val)
        q = [info]
        dfs(root, info)
        ans = []
        while q:
            tmp = []
            poll = q[0][0]
            while q and q[0][0] == poll:
                tmp.append(heapq.heappop(q)[2])
            ans.append(tmp)
        return ans
复制代码