C++中二叉树遍历有四种主要方式：1. 前序遍历（根-左-右），递归或栈实现；2. 中序遍历（左-根-右），常用于BST获取有序序列；3. 后序遍历（左-右-根），适用于释放内存；4. 层序遍历（广度优先），使用队列按层访问节点。

在C++中，二叉树的遍历主要有四种常见方式：前序遍历、中序遍历、后序遍历和层序遍历（广度优先）。每种遍历方式访问节点的顺序不同，适用于不同的场景。下面详细介绍这些方法的实现。

1. 二叉树节点定义

在开始遍历之前，先定义一个基本的二叉树节点结构：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

2. 前序遍历（根-左-右）

前序遍历先访问根节点，然后递归地遍历左子树，最后遍历右子树。

递归实现：

Blender Geometry Nodes Script Generator

生成Blender Python (bpy)脚本，该脚本使用node_groups API和GeometryNodeTree接口程序化地创建几何节点修改器树，用于参数化3D资产生成。

下载

void preorder(TreeNode* root) {
    if (root == nullptr) return;
    cout val     preorder(root->left);
    preorder(root->right);
}

迭代实现（使用栈）：

立即学习“C++免费学习笔记（深入）”；

void preorderIterative(TreeNode* root) {
    if (!root) return;
    stack stk;
    stk.push(root);
    while (!stk.empty()) {
        TreeNode* node = stk.top();
        stk.pop();
        cout val         if (node->right) stk.push(node->right);
        if (node->left) stk.push(node->left);
    }
}

3. 中序遍历（左-根-右）

中序遍历常用于二叉搜索树，可以得到有序序列。

递归实现：

void inorder(TreeNode* root) {
    if (root == nullptr) return;
    inorder(root->left);
    cout val     inorder(root->right);
}

迭代实现：

void inorderIterative(TreeNode* root) {
    stack stk;
    TreeNode* curr = root;
    while (curr || !stk.empty()) {
        while (curr) {
            stk.push(curr);
            curr = curr->left;
        }
        curr = stk.top();
        stk.pop();
        cout val         curr = curr->right;
    }
}

4. 后序遍历（左-右-根）

后序遍历在删除节点或释放内存时很有用。

递归实现：

void postorder(TreeNode* root) {
    if (root == nullptr) return;
    postorder(root->left);
    postorder(root->right);
    cout val }

迭代实现（双栈法）：

void postorderIterative(TreeNode* root) {
    if (!root) return;
    stack stk1, stk2;
    stk1.push(root);
    while (!stk1.empty()) {
        TreeNode* node = stk1.top();
        stk1.pop();
        stk2.push(node);
        if (node->left) stk1.push(node->left);
        if (node->right) stk1.push(node->right);
    }
    while (!stk2.empty()) {
        cout val         stk2.pop();
    }
}

5. 层序遍历（从上到下，从左到右）

层序遍历使用队列实现，适合按层级处理节点。

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

基本上就这些。根据实际需求选择合适的遍历方式，递归写法简洁易懂，迭代写法更节省系统栈空间。不复杂但容易忽略细节，比如空指针判断和入栈顺序。