Leetcode-987. Vertical Order Traversal of a Binary Tree 二叉树的垂序遍历 -python

最新推荐文章于 2022-09-04 11:00:19 发布

原创最新推荐文章于 2022-09-04 11:00:19 发布 · 259 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #dfs #算法 #python

Leetcode 专栏收录该内容

83 篇文章

订阅专栏

本文介绍了一种算法，用于解决二叉树的垂直顺序遍历问题，通过深度优先搜索（DFS）策略，对每个节点的位置进行标记，并最终按X坐标顺序返回结点值列表。

题目

给定二叉树，按垂序遍历返回其结点值。
对位于 (X, Y) 的每个结点而言，其左右子结点分别位于 (X-1, Y-1) 和 (X+1, Y-1)。
把一条垂线从 X = -infinity 移动到 X = +infinity ，每当该垂线与结点接触时，我们按从上到下的顺序报告结点的值（ Y 坐标递减）。
如果两个结点位置相同，则首先报告的结点值较小。
按 X 坐标顺序返回非空报告的列表。每个报告都有一个结点值列表。
链接：https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/

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.

Note:

The tree will have between 1 and 1000 nodes.
Each node’s value will be between 0 and 1000.

Example:

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).

思路及代码

DFS

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def verticalTraversal(self, root: TreeNode) -> List[List[int]]:
        def dfs(node,x,y):
            if not node:
                return
            vals.append([x, y, node.val])
            dfs(node.left, x-1, y-1)
            dfs(node.right, x+1, y-1)
        
        vals = []
        dfs(root, 0, 0)
        vals = sorted(vals, key = lambda x: (x[0], -x[1], x[2]))
        ans = []
        last_x = -10000
        for x, y, val in vals:
            if x != last_x:
                ans.append([])
                last_x = x
            ans[-1].append(val)
        return ans