Question

我刚刚开始使用二叉树，我需要执行一项任务，即对给定的二叉树'[1，null，2,3]'进行预迭代遍历搜索。

我尝试使用发现的新的二叉树模块，但是它没有用，我看到一个youtube视频，其中有人递归地执行了该视频，但我只是想不通。

#Input = [1,null, 2,3]
# 1
#  \
#   2
#  /
# 3
#Expected output = [1,2,3]


# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:

我一无所知，我写了一个算法，但是不能将其转换为实际的功能代码。我也不明白根：TreeNode是如何工作的。是否会将列表中的每个元素都转换为TreeNode对象？到目前为止，我最好的尝试就是这样做，显然在很多方面都是错误的。

def preorderTraversal(self, root: TreeNode) -> List[int]:
    result = []
    for i in root:
        if i =! root[0] and root.left =! None:
            root.left = i
            if root.left =! null:
                root.left.left = i
            elif root.left == null:
                root.right.left = i
            elif root.left
            result.append(i)
        elif root.right == None:
            root.right = i

        else:
            continue

Answer 1

您可以为其使用队列数据结构。

queue = []
result = []
queue.append(root)

while queue:
    node = queue.pop()
    result.append(node.val)

    if node.left is not None:
        queue.insert(0, node.left)

    if node.right is not None:
        queue.insert(0, node.right)

return result

Answer 2

几点：

函数preorderTraversal应该没有self参数；它不是类的方法。
我修改了TreeNode类，以便更方便地指定其子TreeNode对象。
函数preorderTraversal以一个TreeNode对象作为参数。正如我在评论中提到的那样，您的说法#Input = [1,null, 2,3]难以理解。
您需要保留未访问的TreeNode对象的后进先出（LIFO）stack，以实现迭代（而不是递归解决方案）。在下面的代码中，变量nodes用于实现此目的。

代码：

from typing import List

class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.x = val
        self.left = left
        self.right = right

n3 = TreeNode(3)
n2 = TreeNode(2, left=n3)
n1 = TreeNode(1, right=n2)

def preorderTraversal(root: TreeNode) -> List[int]:
    result = []
    nodes = []
    nodes.append(root) # initial node to visit
    while len(nodes): # any nodes left top visit?
        node = nodes.pop() # get topmost element, which is the next node to visit
        result.append(node.x) # "output" its value before children are visited
        if node.right is not None:
            # show this node must be visited
            nodes.append(node.right) # push first so it is popped after node.left
        if node.left is not None:
            # show this node must be visited
            nodes.append(node.left)
    return result

print(preorderTraversal(n1))

打印：

[1, 2, 3]

或更复杂的树：

        10 
      /   \ 
    8      2 
  /  \    / 
3     5  2 

n3 = TreeNode(3)
n5 = TreeNode(5)
n8 = TreeNode(8, left=n3, right=n5)
n2a = TreeNode(2)
n2b = TreeNode(2, left=n2a)
n10 = TreeNode(10, left=n8, right=n2b)

print(preorderTraversal(n10))

打印：

[10, 8, 3, 5, 2, 2]

Answer 3

这是来自 leetcode 平台的 problem，这是我的解决方案。运行时间：28 毫秒，比 Python3 在线提交的二叉树预序遍历快 81.08%。

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        
        return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

二叉树序遍历

3 个答案: