二叉树--前中后序遍历

本文介绍了一种使用栈实现二叉树的前序、中序和后序遍历的方法。通过具体的Java代码示例展示了如何构造二叉树并进行不同顺序的遍历。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

package arithmetic;

import java.util.Stack;

/**
 * 二叉树的 前中后 序遍历
 */
public class PrintNode {


    public static void main(String[] args) {
        Node n1 = new Node(1 + "");
        Node n2 = new Node(2 + "");
        Node n3 = new Node(3 + "");
        Node n4 = new Node(4 + "");
        Node n5 = new Node(5 + "");
        Node n6 = new Node(6 + "");
        Node n7 = new Node(7 + "");
        n1.left = n2;
        n1.right = n3;

        n2.left = n4;
        n2.right = n5;

        n3.left = n6;
        n3.right = n7;

        //先序遍历
        printFirst(n1);
        System.out.println();
        //后序遍历
        printEnd(n1);
        System.out.println();
        //中序遍历
        printMid(n1);

    }

    private static void printMid(Node n1) {
        if (n1 == null) return;
        Stack<Node> stack = new Stack<>();
        Node head = n1;
        while (!stack.isEmpty() || head != null) {
            if (head != null) {//head一直往左走,将左节点都压栈
                stack.push(head);
                head = head.left;
            } else {  //head==null,栈中取值打印,并往右走,进入下一个轮询
                head = stack.pop();
                head.print();
                head = head.right;
            }
        }
    }

    private static void printEnd(Node n1) {
        if (n1 == null) return;
        Stack<Node> stack = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        stack.push(n1);
        while (!stack.isEmpty()) {
            Node pop = stack.pop();
            stack2.push(pop);
            if (pop.left != null) {
                stack.push(pop.left);
            }
            if (pop.right != null) {
                stack.push(pop.right);
            }
        }
        while (!stack2.isEmpty()) {
            stack2.pop().print();
        }
    }

    private static void printFirst(Node n1) {
        if (n1 == null) return;
        Stack<Node> stack = new Stack<>();
        stack.push(n1);
        while (!stack.isEmpty()) {
            Node pop = stack.pop();
            pop.print();
            if (pop.right != null) {
                stack.push(pop.right);
            }
            if (pop.left != null) {
                stack.push(pop.left);
            }
        }
    }


    static class Node {
        Node left;
        Node right;
        String name;
        Node(String name) {
            this.name = name;
        }
        void print() {
            System.out.print(name + " ");
        }
    }
}
### 关于二叉树序、中序和后序遍历的题目与解法 #### 一、基本概念 二叉树的三种主要遍历方式分别是遍历(Pre-order Traversal)、中序遍历(In-order Traversal)以及后序遍历(Post-order Traversal)。这三种遍历的核心在于访问根节点的时间不同。 - **遍历**:按照“根 -> 左子树 -> 右子树”的顺序进行访问。 - **中序遍历**:按照“左子树 -> 根 -> 右子树”的顺序进行访问。 - **后序遍历**:按照“左子树 -> 右子树 -> 根”的顺序进行访问。 这些遍历可以通过递归实现,也可以通过迭代配合栈来完成[^1]。 --- #### 二、典型题目解析 ##### 题目1:已知遍历和中序遍历序列,求后序遍历序列 给定一棵二叉树遍历 `preorder` 和中序遍历 `inorder` 序列,要求返回该二叉树后序遍历序列。 ###### 解法: 可以利用分治的思想解决此问题。具体步骤如下: 1. 遍历的第一个元素即为当子树的根节点。 2. 在中序遍历中找到该根节点的位置,则其左边部分表示左子树,右边部分表示右子树。 3. 对左右子树分别递归调用相同逻辑。 4. 将结果逆序即可得到最终的后序遍历序列。 以下是 Python 实现代码: ```python def buildTree(preorder, inorder): if not preorder or not inorder: return [] root_val = preorder[0] idx = inorder.index(root_val) left_inorder = inorder[:idx] right_inorder = inorder[idx + 1:] left_preorder = preorder[1:1+len(left_inorder)] right_preorder = preorder[1+len(left_inorder):] result = buildTree(left_preorder, left_inorder) + \ buildTree(right_preorder, right_inorder) + [root_val] return result ``` 这种方法基于递归构建子树并逐步拼接结果。 --- ##### 题目2:仅使用栈模拟二叉树的中序遍历 目标是在不使用递归的情况下,借助栈数据结构完成二叉树的中序遍历。 ###### 解法: 核心思想是先尽可能地向左深入,直到无法继续为止;随后回退至上一层级,并尝试访问右侧分支。 以下是 C++ 的实现代码: ```cpp vector<int> inorderTraversal(TreeNode* root) { vector<int> res; stack<TreeNode*> stk; while (root || !stk.empty()) { while (root) { stk.push(root); root = root->left; // 不断进入左子树 } root = stk.top(); stk.pop(); res.push_back(root->val); // 处理当节点 root = root->right; // 转向右子树 } return res; } ``` 这段代码展示了如何通过显式的栈操作替代隐式函数调用堆栈[^3]。 --- ##### 题目3:验证某序列是否为合法的后序遍历 输入一个整数数组,判断它是否可能是某个二叉搜索树的后序遍历结果。 ###### 解法: 对于一颗 BST 来说,在后序遍历过程中最后一个数字必然是根节点。因此可以根据这一特性划分左右子树范围,并进一步校验各区间内部性质。 以下是 Java 版本解决方案: ```java public boolean verifyPostorder(int[] postorder) { return recur(postorder, 0, postorder.length - 1); } private boolean recur(int[] postorder, int i, int j){ if(i >= j) return true; int p = i; while(postorder[p] < postorder[j]) p++; int m = p; while(postorder[p] > postorder[j]) p++; return p == j && recur(postorder,i,m-1)&&recur(postorder,m,j-1); } ``` 这里采用了分而治之策略反复检验每一段区间的合法性[^4]。 --- ### 总结 以上介绍了几种常见的涉及二叉树遍历的相关算法及其应用实例。无论是采用何种形式表达——递归还是非递归版本——都需要深刻理解各自特点以便灵活运用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值