python 实现二叉树层次、前序、中序、后序遍历

借助队列实现层次遍历：

from collections import deque
import typing


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


def level_order(root: TreeNode | None) -> typing.List[int]:
    queue: deque[TreeNode] = deque()
    queue.append(root)
    res = []

    while queue:
        node: TreeNode = queue.popleft()
        res.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return res

可以使用递归和栈来实现，递归实现如下

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


def preorderTraversal(root):
    if not root:
        return []
    result = []
    result.append(root.val)  # 访问根节点
    result.extend(preorderTraversal(root.left))  # 递归遍历左子树
    result.extend(preorderTraversal(root.right))  # 递归遍历右子树
    return result


def inorderTraversal(root):
    if not root:
        return []
    result = []
    result.extend(inorderTraversal(root.left))  # 递归遍历左子树
    result.append(root.val)  # 访问根节点
    result.extend(inorderTraversal(root.right))  # 递归遍历右子树
    return result


def postorderTraversal(root):
    if not root:
        return []
    result = []
    result.extend(postorderTraversal(root.left))  # 递归遍历左子树
    result.extend(postorderTraversal(root.right))  # 递归遍历右子树
    result.append(root.val)  # 访问根节点
    return result


# 创建一个二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

# 前序遍历
print("前序遍历：", preorderTraversal(root))
# 中序遍历
print("中序遍历：", inorderTraversal(root))
# 后序遍历
print("后序遍历：", postorderTraversal(root))

以下是使用栈来实现二叉树的前序、中序和后序遍历的示例代码：

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


def preorderTraversal(root):
    if not root:
        return []
    stack = []
    result = []
    node = root
    while node or stack:
        while node:
            result.append(node.val)  # 访问根节点
            stack.append(node)
            node = node.left  # 遍历左子树
        node = stack.pop()
        node = node.right  # 遍历右子树
    return result


def inorderTraversal(root):
    if not root:
        return []
    stack = []
    result = []
    node = root
    while node or stack:
        while node:
            stack.append(node)
            node = node.left  # 遍历左子树
        node = stack.pop()
        result.append(node.val)  # 访问根节点
        node = node.right  # 遍历右子树
    return result


def postorderTraversal(root):
    if not root:
        return []
    stack = []
    result = []
    node = root
    last_visited = None
    while node or stack:
        while node:
            stack.append(node)
            node = node.left  # 遍历左子树
        peek = stack[-1]
        if peek.right and last_visited != peek.right:
            node = peek.right  # 遍历右子树
        else:
            result.append(peek.val)  # 访问根节点
            last_visited = stack.pop()
            node = None
    return result


# 创建一个二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

# 前序遍历
print("前序遍历：", preorderTraversal(root))
# 中序遍历
print("中序遍历：", inorderTraversal(root))
# 后序遍历
print("后序遍历：", postorderTraversal(root))

这段代码使用栈来实现了二叉树的前序、中序和后序遍历。在遍历过程中，通过栈来保存待访问的节点，然后按照遍历顺序出栈并访问节点，同时更新指针指向下一个需要遍历的节点。最终，将遍历结果存储在一个列表中并返回。