二叉树姿势百变：递归、AVL、BST、DFS、BFS解锁新姿势

2024-02-14 09:53:06

作为一名前端开发者，我最近在学习数据结构和算法的过程中，发现二叉树及其相关算法占据了非常重要的地位。它不仅是很多高级算法的基础，而且在实际开发中也有着广泛的应用，例如DOM树的遍历、游戏AI的决策树等等。今天，我就来和大家分享一下我对二叉树的理解，以及几种常见的二叉树算法：递归、AVL树、BST树、DFS和BFS。

深入理解二叉树

二叉树，顾名思义，每个节点最多只有两个子节点的树形结构。这两个子节点分别被称为左子节点和右子节点。二叉树的这种结构特点，决定了它非常适合用来表示层级关系，例如文件系统、组织架构等等。

二叉树有很多种类型，例如满二叉树、完全二叉树、平衡二叉树等等。其中，平衡二叉树是一种非常重要的类型，因为它能够保证在最坏情况下，查找、插入和删除操作的时间复杂度都是O(log n)。

递归：二叉树的万能钥匙

递归是一种非常优雅的编程技巧，它能够将一个复杂的问题分解成若干个相同或类似的子问题，然后通过解决这些子问题来解决原问题。在处理二叉树问题时，递归更是发挥着巨大的作用。

例如，我们可以使用递归来实现二叉树的前序遍历、中序遍历和后序遍历：

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

def preorder_traversal(root):
    if root:
        print(root.val, end=" ")
        preorder_traversal(root.left)
        preorder_traversal(root.right)

def inorder_traversal(root):
    if root:
        inorder_traversal(root.left)
        print(root.val, end=" ")
        inorder_traversal(root.right)

def postorder_traversal(root):
    if root:
        postorder_traversal(root.left)
        postorder_traversal(root.right)
        print(root.val, end=" ")

AVL树：追求极致平衡

AVL树是一种自平衡的二叉搜索树，它通过旋转操作来保持树的平衡，从而保证了在最坏情况下，查找、插入和删除操作的时间复杂度都是O(log n)。AVL树的实现比较复杂，但是它在性能方面有着很大的优势，因此在一些对性能要求较高的场景下，例如数据库索引，AVL树得到了广泛的应用。

BST树：有序数据的最佳选择

BST树，也就是二叉搜索树，是一种特殊的二叉树，它的左子树上的所有节点都小于根节点，右子树上的所有节点都大于根节点。BST树非常适合用来存储有序数据，因为它能够保证在最坏情况下，查找、插入和删除操作的时间复杂度都是O(log n)。

def insert(root, val):
    if root is None:
        return TreeNode(val)
    if val < root.val:
        root.left = insert(root.left, val)
    else:
        root.right = insert(root.right, val)
    return root

DFS：勇往直前的探险家

DFS，也就是深度优先搜索，是一种图遍历算法。在二叉树中，DFS会沿着一条路径一直走到尽头，然后再回溯到上一个节点，继续沿着另一条路径走到尽头，以此类推，直到遍历完所有的节点。DFS通常使用栈来实现。

def dfs(root):
    if root is None:
        return
    stack = [root]
    while stack:
        node = stack.pop()
        print(node.val, end=" ")
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)

BFS：稳扎稳打的探索者

BFS，也就是广度优先搜索，也是一种图遍历算法。在二叉树中，BFS会一层一层地遍历节点，先遍历完一层的所有节点，然后再遍历下一层的所有节点，以此类推，直到遍历完所有的节点。BFS通常使用队列来实现。

from collections import deque

def bfs(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        node = queue.popleft()
        print(node.val, end=" ")
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)