层序遍历二叉树的方法汇总

2024-01-20 17:53:15

层序遍历，是一种遍历二叉树的方法，它从根节点开始，逐层地访问所有节点，从左到右。层序遍历可以用来打印二叉树的结构，或者计算二叉树的节点数、高度、直径等属性。

层序遍历有两种基本方法：广度优先搜索(BFS)和深度优先搜索(DFS)。BFS从根节点开始，依次访问所有第一层节点，然后访问所有第二层节点，依此类推，直到所有节点都已被访问。DFS从根节点开始，一直向下访问，直到遇到叶子节点，然后返回上一个节点，继续向下访问。

在Python中，层序遍历二叉树可以使用队列(Queue)和栈(Stack)两种数据结构来实现。使用队列实现BFS，使用栈实现DFS。

代码示例

广度优先搜索(BFS)

def level_order_traversal_bfs(root):
    """
    层序遍历二叉树，广度优先搜索

    Args:
        root: 二叉树的根节点

    Returns:
        list: 二叉树的层序遍历结果
    """
    if not root:
        return []

    queue = [root]
    result = []

    while queue:
        level_size = len(queue)
        level_values = []

        for _ in range(level_size):
            node = queue.pop(0)
            level_values.append(node.val)

            if node.left:
                queue.append(node.left)

            if node.right:
                queue.append(node.right)

        result.append(level_values)

    return result

深度优先搜索(DFS)

def level_order_traversal_dfs(root):
    """
    层序遍历二叉树，深度优先搜索

    Args:
        root: 二叉树的根节点

    Returns:
        list: 二叉树的层序遍历结果
    """
    if not root:
        return []

    stack = [root]
    result = []

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

        if node.right:
            stack.append(node.right)

        if node.left:
            stack.append(node.left)

    return result

优化技巧

使用双端队列(Deque)

可以使用双端队列(Deque)来优化BFS的实现。Deque是一种特殊的队列，它允许从两端进行添加和删除元素。使用Deque可以避免在BFS中将节点从队列中弹出后又重新插入队列的操作，从而提高效率。

from collections import deque

def level_order_traversal_bfs_deque(root):
    """
    层序遍历二叉树，广度优先搜索，使用双端队列

    Args:
        root: 二叉树的根节点

    Returns:
        list: 二叉树的层序遍历结果
    """
    if not root:
        return []

    queue = deque([root])
    result = []

    while queue:
        level_size = len(queue)
        level_values = []

        for _ in range(level_size):
            node = queue.popleft()
            level_values.append(node.val)

            if node.left:
                queue.append(node.left)

            if node.right:
                queue.append(node.right)

        result.append(level_values)

    return result

使用递归

还可以使用递归来实现BFS和DFS。递归的实现方式更为简洁，但是效率可能不如迭代的方式。

def level_order_traversal_bfs_recursive(root):
    """
    层序遍历二叉树，广度优先搜索，递归实现

    Args:
        root: 二叉树的根节点

    Returns:
        list: 二叉树的层序遍历结果
    """
    if not root:
        return []

    queue = [root]
    result = []

    def bfs(level):
        if not queue:
            return

        level_size = len(queue)
        level_values = []

        for _ in range(level_size):
            node = queue.pop(0)
            level_values.append(node.val)

            if node.left:
                queue.append(node.left)

            if node.right:
                queue.append(node.right)

        result.append(level_values)
        bfs(level + 1)

    bfs(0)

    return result


def level_order_traversal_dfs_recursive(root):
    """
    层序遍历二叉树，深度优先搜索，递归实现

    Args:
        root: 二叉树的根节点

    Returns:
        list: 二叉树的层序遍历结果
    """
    if not root:
        return []

    stack = [root]
    result = []

    def dfs():
        if not stack:
            return

        node = stack.pop()
        result.append(node.val)

        if node.right:
            stack.append(node.right)

        if node.left:
            stack.append(node.left)

        dfs()

    dfs()

    return result