二叉树非递归遍历与Morris算法优化详解

1. 二叉树遍历基础与核心逻辑

作为一名经历过无数次算法面试的老手，我深知二叉树遍历在技术面试中的高频出现率。今天我想和大家深入探讨非递归遍历的实现技巧，以及如何通过Morris算法进行极致优化。相信看完这篇，你不仅能轻松应对面试，更能真正理解这些算法背后的精妙设计。

首先明确一点：递归遍历虽然简洁，但在实际工程中往往存在栈溢出风险。非递归实现不仅能规避这个问题，更能体现你对数据结构和算法本质的理解。所有非递归遍历的核心思想都是手动模拟递归的系统栈，通过栈的"后进先出"特性控制节点的访问顺序。

关键理解：递归的本质是系统帮我们维护了一个调用栈，而非递归实现则是我们自己用数据结构显式地维护这个栈。

2. 前序遍历的非递归实现

2.1 标准栈实现

前序遍历（根→左→右）的非递归实现可以说是三种遍历中最直观的。其核心逻辑是：先处理根节点，再利用栈的"后进先出"特性，先压右子树、后压左子树，保证弹出时左子树先处理。

java复制public List<Integer> preorderTraversal(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    List<Integer> result = new ArrayList<>();
    if(root == null) return result;
    
    stack.push(root);
    while(!stack.isEmpty()){
        TreeNode cur = stack.pop();
        result.add(cur.val); // 处理当前节点
        if(cur.right != null) stack.push(cur.right); // 先右
        if(cur.left != null) stack.push(cur.left); // 后左
    }
    return result;
}

为什么这个顺序能保证前序遍历？

1. 每次弹出栈顶节点立即处理，保证"根优先"
2. 右子树先入栈，左子树后入栈，保证左子树先弹出
3. 整个过程就像深度优先搜索，沿着左子树一路向下

2.2 时间复杂度分析

• 时间复杂度：O(n)，每个节点恰好被访问一次
• 空间复杂度：O(h)，h为树的高度，最坏情况下（斜树）为O(n)

3. 中序遍历的非递归实现

3.1 标准实现与思考

中序遍历（左→根→右）的实现比前序稍复杂，核心逻辑是：先遍历到左子树最深处（沿途节点入栈），回溯时处理根节点，最后处理右子树。

java复制public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new LinkedList<>();
    TreeNode curr = root;
    
    while(curr != null || !stack.isEmpty()){
        // 一路向左
        while(curr != null){
            stack.push(curr);
            curr = curr.left;
        }
        curr = stack.pop();
        result.add(curr.val); // 处理当前节点
        curr = curr.right; // 转向右子树
    }
    return result;
}

为什么中序遍历不能像前序那样先入栈根节点？

这是一个很好的思考题。前序遍历可以先入栈根节点是因为它的核心是"根优先"；而中序遍历的核心是"左子树优先"，如果直接入栈根节点：

1. 根节点入栈后直接弹出处理 → 违背"左优先"原则
2. 若入栈后不弹出，后续无法控制"先遍历左子树"

3.2 双条件循环的奥秘

注意到中序遍历的while条件是curr != null || !stack.isEmpty()，这比前序遍历多了一个条件。这是因为：

1. curr != null处理两种情况：
   • 初始阶段栈为空，但指针指向根节点
   • 遍历右子树时，指针指向新的节点
2. !stack.isEmpty()处理：
   • 指针走到空（左子树遍历完），但栈里还有未处理的根节点

4. 后序遍历的非递归实现

4.1 取巧的反转法

后序遍历（左→右→根）的标准非递归实现较为复杂，需要记录节点的访问状态。但在面试中，我们可以使用一个取巧的方法：对前序遍历稍作修改，最后反转结果。

java复制public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> result = new LinkedList<>();
    Stack<TreeNode> stack = new Stack<>();
    if(root == null) return result;
    
    stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node = stack.pop();
        result.addFirst(node.val); // 添加到头部，相当于反转
        
        // 注意入栈顺序与前序相反
        if(node.left != null) stack.push(node.left);
        if(node.right != null) stack.push(node.right);
    }
    return result;
}

为什么这个方法有效？

1. 标准前序是"根→左→右"，入栈顺序是"右→左"
2. 如果我们改为"根→右→左"，入栈顺序就是"左→右"
3. 将"根→右→左"的结果反转，就得到"左→右→根"

4.2 正统的双栈法

虽然反转法简单，但了解正统的实现也很重要：

java复制public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    TreeNode prev = null; // 记录前一个访问的节点
    
    while(root != null || !stack.isEmpty()){
        while(root != null){
            stack.push(root);
            root = root.left;
        }
        
        root = stack.pop();
        if(root.right == null || root.right == prev){
            // 右子树已访问或为空
            result.add(root.val);
            prev = root;
            root = null;
        } else {
            // 右子树未访问
            stack.push(root);
            root = root.right;
        }
    }
    return result;
}

这种方法通过记录前一个访问的节点来判断右子树是否已处理，虽然复杂但更符合后序遍历的本质。

5. Morris遍历算法

5.1 算法核心思想

Morris遍历的惊人之处在于它实现了O(1)空间复杂度的遍历，核心思想是利用树中的空指针来临时保存信息，避免使用额外空间。

Morris遍历的关键步骤：

1. 如果当前节点的左孩子为空，处理当前节点并转向右孩子
2. 如果左孩子不为空：
   • 找到当前节点左子树的最右节点（前驱节点）
   • 如果前驱节点的右孩子为空，将其指向当前节点，然后转向左孩子
   • 如果前驱节点的右孩子是当前节点（说明已建立链接），断开链接，处理当前节点，然后转向右孩子

5.2 Morris中序遍历实现

java复制public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    TreeNode curr = root;
    
    while(curr != null){
        if(curr.left == null){
            res.add(curr.val);
            curr = curr.right;
        } else {
            // 找到前驱节点
            TreeNode prev = curr.left;
            while(prev.right != null && prev.right != curr){
                prev = prev.right;
            }
            
            if(prev.right == null){
                // 建立线索
                prev.right = curr;
                curr = curr.left;
            } else {
                // 断开线索
                prev.right = null;
                res.add(curr.val);
                curr = curr.right;
            }
        }
    }
    return res;
}

5.3 Morris前序遍历实现

java复制public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    TreeNode curr = root;
    
    while(curr != null){
        if(curr.left == null){
            res.add(curr.val);
            curr = curr.right;
        } else {
            TreeNode prev = curr.left;
            while(prev.right != null && prev.right != curr){
                prev = prev.right;
            }
            
            if(prev.right == null){
                res.add(curr.val); // 与前序的唯一区别
                prev.right = curr;
                curr = curr.left;
            } else {
                prev.right = null;
                curr = curr.right;
            }
        }
    }
    return res;
}

5.4 Morris算法的优势与局限

优势：

• O(1)空间复杂度，极致优化
• 不需要递归或显式栈
• 在某些内存受限的场景非常有用

局限：

• 会临时修改树的结构（虽然最后会恢复）
• 实现较复杂，容易出错
• 在实际工程中，除非特别需要，一般还是使用标准非递归实现

6. 二叉树展开为链表的Morris解法

这是一个经典问题，要求将二叉树原地展开为一个单链表，且顺序与前序遍历相同。使用Morris算法可以优雅地解决：

java复制public void flatten(TreeNode root) {
    TreeNode curr = root;
    while(curr != null){
        if(curr.left != null){
            // 找到左子树的最右节点
            TreeNode prev = curr.left;
            while(prev.right != null){
                prev = prev.right;
            }
            
            // 将右子树接到前驱节点
            prev.right = curr.right;
            // 左子树移到右边
            curr.right = curr.left;
            curr.left = null;
        }
        curr = curr.right;
    }
}

关键理解：

1. 当前节点的左子树的最右节点就是前驱节点
2. 将当前节点的右子树接到前驱节点的右边
3. 将左子树移到右边，左指针置空
4. 沿着新的右指针继续处理

7. 遍历算法对比与面试技巧

7.1 三种非递归遍历对比

7.2 面试实战建议

1. 优先掌握标准非递归实现：特别是前序和中序，代码简洁明了
2. 后序遍历可用反转法：面试时先说明思路，再实现更复杂的正统方法
3. Morris遍历作为加分项：如果时间允许，可以展示对极致优化的理解
4. 注意边界条件：空树、单节点、左/右斜树等特殊情况
5. 复杂度分析要准确：特别是空间复杂度与树高的关系

8. 常见问题与调试技巧

8.1 常见错误

1. 中序遍历忘记移动指针：

   java复制while(curr != null){  // 错误：缺少!stack.isEmpty()条件
       stack.push(curr);
       curr = curr.left;
   }
   

2. 后序遍历的状态判断错误：

   java复制if(root.right == null){  // 错误：还需要判断root.right == prev
       result.add(root.val);
       prev = root;
       root = null;
   }
   

3. Morris遍历中未正确恢复树结构：

   java复制if(prev.right == curr){
       // 忘记断开链接
       res.add(curr.val);  // 应该在断开链接后处理
       curr = curr.right;
   }
   

8.2 调试技巧

1. 小规模测试：从3个节点的简单树开始验证
2. 打印栈状态：在循环中打印栈内节点值，观察遍历顺序
3. 可视化遍历过程：在纸上画出树结构，手动模拟算法执行
4. 边界测试：空树、单节点树、完全斜树等特殊情况

9. 扩展思考与实际应用

9.1 为什么这些算法重要？

二叉树遍历是许多复杂算法的基础，比如：

• 二叉搜索树的验证和操作
• 树的序列化和反序列化
• 表达式树的求值
• 文件系统的遍历

9.2 如何选择适当的遍历方法？

1. 前序遍历：适合需要先处理根节点再处理子树的场景，如复制树结构
2. 中序遍历：二叉搜索树的有序输出
3. 后序遍历：需要先处理子树再处理根节点的场景，如计算子树信息
4. Morris遍历：内存受限环境，或需要极致优化的场景

9.3 性能优化实践

在实际工程中，除了算法选择外，还可以：

1. 对于固定结构的树，考虑预计算和缓存遍历结果
2. 使用迭代器模式实现惰性遍历
3. 在多线程环境下注意树的并发修改问题

10. 总结与个人心得

经过多年的算法实践和面试经验，我对二叉树遍历有几点深刻体会：

1. 理解比记忆更重要：掌握每种遍历的核心思想，而不要死记硬背代码模板
2. 从递归到非递归的过渡：理解系统调用栈的模拟过程是关键突破点
3. Morris算法体现的智慧：利用空闲指针存储信息的思想在其他问题中也很有用
4. 调试是学习的最佳途径：亲手实现并在调试器中观察执行流程，理解会深刻得多

最后分享一个小技巧：在面试中，可以先写出递归版本，然后说"我们知道递归可能有栈溢出风险，下面我展示如何改为非递归实现"，这样既展示了基础知识，又体现了进阶能力。