二叉树遍历：递归与非递归实现详解

1. 二叉树遍历的核心概念解析

二叉树作为数据结构中最基础的树形结构之一，在算法面试和实际工程中都有广泛应用。理解其遍历方式，是掌握树结构操作的第一步。遍历本质上是对树中所有节点进行系统性访问的策略，根据访问顺序的不同，主要分为四种经典方式：

前序遍历（Pre-order）：按照"根节点-左子树-右子树"的顺序访问
中序遍历（In-order）：按照"左子树-根节点-右子树"的顺序访问
后序遍历（Post-order）：按照"左子树-右子树-根节点"的顺序访问
层序遍历（Level-order）：按层级从上到下、每层从左到右访问

每种遍历方式都有其特定应用场景。比如前序遍历常用于创建树的副本，中序遍历在二叉搜索树中能得到有序序列，后序遍历适合计算子树信息，而层序遍历则常用于寻找最短路径或树的最小高度。

2. 递归实现详解

2.1 前序遍历递归实现

前序遍历的递归实现最为直观：

cpp复制void preOrder(TreeNode* root) {
    if (!root) return;
    cout << root->val << " ";  // 先访问根节点
    preOrder(root->left);      // 递归左子树
    preOrder(root->right);     // 递归右子树
}

递归的终止条件是遇到空节点。时间复杂度O(n)，空间复杂度取决于树高，最坏情况O(n)。

注意：在实际工程中，如果树非常深，递归可能导致栈溢出。这时需要考虑非递归实现或增加栈大小。

2.2 中序遍历递归实现

中序遍历的递归版本与前序类似，只是访问顺序不同：

cpp复制void inOrder(TreeNode* root) {
    if (!root) return;
    inOrder(root->left);      // 先递归左子树
    cout << root->val << " "; // 再访问根节点
    inOrder(root->right);     // 最后递归右子树
}

对于二叉搜索树(BST)，中序遍历会得到一个升序序列，这个特性常被用于BST验证和相关算法。

2.3 后序遍历递归实现

后序遍历的递归模板：

cpp复制void postOrder(TreeNode* root) {
    if (!root) return;
    postOrder(root->left);    // 先递归左子树
    postOrder(root->right);   // 再递归右子树
    cout << root->val << " "; // 最后访问根节点
}

后序遍历的特点是只有访问完左右子树后才能处理当前节点，这种特性使其适合进行子树统计或内存释放操作。

3. 非递归实现详解

3.1 前序遍历非递归实现

非递归实现需要显式使用栈来模拟递归调用：

cpp复制void preOrderIterative(TreeNode* root) {
    if (!root) return;
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        cout << node->val << " ";
        // 右孩子先入栈，保证左孩子先处理
        if (node->right) s.push(node->right);
        if (node->left) s.push(node->left);
    }
}

这个实现巧妙地利用了栈的LIFO特性，通过先将右节点入栈，确保左节点总是先被处理。

3.2 中序遍历非递归实现

中序遍历的非递归实现稍复杂，需要维护当前节点指针和栈：

cpp复制void inOrderIterative(TreeNode* root) {
    stack<TreeNode*> s;
    TreeNode* curr = root;
    while (curr || !s.empty()) {
        // 先到达最左节点
        while (curr) {
            s.push(curr);
            curr = curr->left;
        }
        curr = s.top();
        s.pop();
        cout << curr->val << " ";
        // 转向右子树
        curr = curr->right;
    }
}

这个算法的核心思想是模拟递归的中序遍历过程：尽可能向左走，然后回溯处理节点，再转向右子树。

3.3 后序遍历非递归实现

后序遍历的非递归实现最为复杂，需要记录节点的访问状态：

cpp复制void postOrderIterative(TreeNode* root) {
    if (!root) return;
    stack<TreeNode*> s;
    TreeNode* lastVisited = nullptr;
    TreeNode* curr = root;
    while (curr || !s.empty()) {
        if (curr) {
            s.push(curr);
            curr = curr->left;
        } else {
            TreeNode* peek = s.top();
            if (peek->right && peek->right != lastVisited) {
                curr = peek->right;
            } else {
                cout << peek->val << " ";
                lastVisited = peek;
                s.pop();
            }
        }
    }
}

这里使用lastVisited指针来区分是从左子树返回(需要处理右子树)还是从右子树返回(可以处理当前节点)。

4. 层序遍历实现

4.1 基本层序遍历

层序遍历使用队列而非栈，实现广度优先搜索(BFS)：

cpp复制void levelOrder(TreeNode* root) {
    if (!root) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        cout << node->val << " ";
        if (node->left) q.push(node->left);
        if (node->right) q.push(node->right);
    }
}

4.2 带层级信息的层序遍历

有时我们需要知道节点所在的层级，可以改进实现：

cpp复制void levelOrderWithLevel(TreeNode* root) {
    if (!root) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; ++i) {
            TreeNode* node = q.front();
            q.pop();
            cout << node->val << " ";
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
        cout << endl; // 换行表示新层级
    }
}

这种实现通过记录每层开始时的队列大小，确保同一层的节点被一起处理。

5. 性能对比与应用场景

5.1 递归与非递归的比较

5.2 各遍历方式的应用场景

• 前序遍历：复制树结构、序列化二叉树、前缀表达式
• 中序遍历：BST有序输出、表达式树求值
• 后序遍历：删除树结构、计算子树信息、后缀表达式
• 层序遍历：寻找最短路径、打印树结构、宽度优先搜索

6. 常见问题与调试技巧

6.1 栈溢出问题

当树非常深时（如退化成链表），递归实现可能导致栈溢出。解决方法：

1. 改用非递归实现
2. 增加线程栈大小（系统依赖）
3. 使用尾递归优化（某些编译器支持）

6.2 非递归实现的常见错误

1. 忘记检查空指针：在访问node->left或node->right前应检查node是否为空
2. 栈操作顺序错误：特别是后序遍历中，容易混淆左右子树的处理顺序
3. 终止条件不完整：循环条件应同时考虑当前节点和栈是否为空

6.3 调试建议

1. 对小树(3-5个节点)手动模拟遍历过程
2. 打印中间状态：在关键步骤打印栈/队列内容
3. 使用可视化工具：如Graphviz绘制二叉树，直观验证遍历顺序

7. 扩展与变种

7.1 Morris遍历

一种空间复杂度O(1)的遍历方法，通过修改树结构实现：

cpp复制void inOrderMorris(TreeNode* root) {
    TreeNode* curr = root;
    while (curr) {
        if (!curr->left) {
            cout << curr->val << " ";
            curr = curr->right;
        } else {
            TreeNode* prev = curr->left;
            while (prev->right && prev->right != curr)
                prev = prev->right;
            if (!prev->right) {
                prev->right = curr;
                curr = curr->left;
            } else {
                prev->right = nullptr;
                cout << curr->val << " ";
                curr = curr->right;
            }
        }
    }
}

Morris遍历的优点是无需额外空间，但会临时修改树结构，不适合并发环境。

7.2 迭代式深度优先搜索

统一风格的迭代遍历模板，通过标记已访问节点：

cpp复制void postOrderIterativeUniform(TreeNode* root) {
    stack<TreeNode*> s;
    if (root) s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        if (node) {
            s.pop();
            s.push(node); s.push(nullptr); // 标记待处理节点
            if (node->right) s.push(node->right);
            if (node->left) s.push(node->left);
        } else {
            s.pop(); // 弹出nullptr
            node = s.top(); s.pop();
            cout << node->val << " ";
        }
    }
}

这种方法通过插入nullptr标记需要处理的节点，可以用同一模板实现三种DFS遍历。

在实际工程中，二叉树遍历的选择需要考虑具体场景、数据特性和性能要求。递归实现简洁但可能有栈溢出风险，非递归实现更可控但代码复杂。理解这些实现的底层原理，才能在不同场景下做出合适的选择。