深入理解CLRS项目中二叉树遍历与表示方法

最新推荐文章于 2025-06-12 15:37:34 发布

袁立春Spencer

最新推荐文章于 2025-06-12 15:37:34 发布

阅读量284

点赞数 5

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/gitblog_00258/article/details/148508479

深入理解CLRS项目中二叉树遍历与表示方法

CLRS 📚 Solutions to Introduction to Algorithms Third Edition 项目地址: https://gitcode.com/gh_mirrors/clr/CLRS

本文基于walkccc/CLRS项目中第10章第4节的内容，深入讲解二叉树的多种表示方法和遍历算法，帮助读者掌握这些基础但重要的数据结构知识。

二叉树的结构表示与绘制

在数据结构中，二叉树可以通过多种方式表示。题目10.4-1展示了一种常见的表格表示法，其中每个节点包含三个关键信息：键值(key)、左子节点(left)和右子节点(right)。

以索引6为根的二叉树结构如下：

        18
       /  \
     12    10
    /     / \
   7     2   21
  /
5

这种表示方法清晰地展示了节点间的父子关系，其中NIL表示空指针。理解这种表示法对于后续实现各种遍历算法至关重要。

二叉树的递归遍历

题目10.4-2要求实现一个O(n)时间复杂度的递归遍历算法。递归是处理树结构最自然的方式之一，因为它完美匹配了树的递归定义。

PRINT-BINARY-TREE(T)
    PRINT-BINARY-TREE-AUX(T.root)

PRINT-BINARY-TREE-AUX(x)
    if node != NIL
        PRINT-BINARY-TREE-AUX(x.left)  // 先递归遍历左子树
        print x.key                    // 然后访问当前节点
        PRINT-BINARY-TREE-AUX(x.right) // 最后递归遍历右子树

这是典型的中序遍历(左-根-右)实现，时间复杂度为O(n)，因为每个节点恰好被访问一次。递归深度取决于树的高度，最坏情况下(树退化为链表)空间复杂度为O(n)。

二叉树的非递归遍历

题目10.4-3要求使用栈实现非递归遍历。递归本质上使用了系统栈，我们可以显式地使用栈来模拟递归过程。

PRINT-BINARY-TREE(T, S)
    PUSH(S, T.root)
    while !STACK-EMPTY(S)
        x = S[S.top]
        while x != NIL      // 一直向左走，直到最左叶子节点
            PUSH(S, x.left)
            x = S[S.top]
        POP(S)              // 弹出栈顶的NIL
        if !STACK-EMPTY(S)  // 访问节点，转向右子树
            x = POP(S)
            print x.key
            PUSH(S, x.right)

这个实现同样完成中序遍历，时间复杂度仍为O(n)。使用栈使得我们可以控制遍历过程，避免了递归可能导致的栈溢出问题。

任意树的遍历

题目10.4-4处理的是更一般的树结构，使用左孩子-右兄弟表示法。这种表示法将任意树转化为二叉树形式，其中节点的左指针指向第一个孩子，右指针指向下一个兄弟。

PRINT-LCRS-TREE(T)
    x = T.root
    if x != NIL
        print x.key                // 先访问当前节点
        lc = x.left-child          // 然后处理第一个孩子
        if lc != NIL
            PRINT-LCRS-TREE(lc)
            rs = lc.right-sibling   // 最后处理所有兄弟节点
            while rs != NIL
                PRINT-LCRS-TREE(rs)
                rs = rs.right-sibling

这种遍历方式实际上是树的先序遍历(根-孩子)，时间复杂度为O(n)，因为每个节点只被访问一次。

常量空间复杂度的二叉树遍历

题目10.4-5提出了一个挑战：在不使用递归和栈的情况下遍历二叉树，且只能使用常量额外空间。这需要使用线索二叉树的思想，利用节点的父指针进行遍历。

PRINT-KEY(T)
    prev = NIL
    x = T.root
    while x != NIL
        if prev = x.parent
            print x.key            // 第一次访问节点时打印
            prev = x
            if x.left
                x = x.left         // 优先向左走
            else
                if x.right
                    x = x.right    // 没有左孩子就向右走
                else 
                    x = x.parent   // 叶子节点则回溯
        else if prev == x.left and x.right != NIL
                prev = x
                x = x.right        // 从左孩子返回且有右孩子时转向右
        else
                prev = x
                x = x.parent       // 其他情况回溯

这种Morris遍历的变种实现了O(n)时间复杂度和O(1)空间复杂度，但逻辑较为复杂，需要仔细跟踪遍历路径。