C++二叉树三种遍历全解析及其进阶使用：前序遍历的前是什么前

C++二叉树三种遍历方法全图解：前序遍历的前是什么前！

在数据结构中，二叉树是一种非常重要的非线性数据结构。它由节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的遍历是指按照某种顺序访问树中的所有节点。常见的遍历方法有三种：前序遍历、中序遍历和后序遍历。本文将通过一个具体的例子，详细介绍这三种遍历方法的概念、遍历过程以及如何在C++中实现它们。

二编：反过来，如何通过前序遍历和中序遍历，中序遍历和后序遍历得出二叉树结构呢，关注博文：每日一题：通过前序与中序遍历、中序与后序遍历构造二叉树，题目见文章末尾。

二叉树基本概念

在介绍遍历方法之前，我们先来了解一下二叉树的基本概念。

节点（Node）：二叉树的基本单位，每个节点包含数据域和两个指针域，分别指向左子节点和右子节点。
根节点（Root）：二叉树的顶层节点，没有父节点。
叶子节点（Leaf）：没有子节点的节点。
深度（Depth）：从根节点到当前节点的路径长度。
高度（Height）：从当前节点到叶子节点的最长路径长度。

常见二叉树结构

三种遍历方法

1. 前序遍历（Preorder Traversal）

前序遍历的顺序是：根节点 -> 左子树 -> 右子树。也就是说，先访问根节点，然后递归地前序遍历左子树，最后递归地前序遍历右子树。

遍历过程：

访问根节点A。直接导出根节点A、节点B、和没有节点的叶子节点D；
前序遍历左子树（B、D、E、G）。节点B左节点搜索完毕，搜索右节点，直接导出节点E（前序遍历的前就是节点先导出），然后有限导出节点E的左节点，然后右节点（本例子无右节点）。

在这里插入图片描述

3. 前序遍历右子树（C、F）。至此左子树搜索完毕，搜索右子树。直接导出右节点C，同时分别搜索节点C的左右节点。

在这里插入图片描述
无左节点，右节点为叶子节点。至此前序遍历结束。

遍历结果：A -> B -> D -> E -> G -> C -> F

2. 中序遍历（Inorder Traversal）

中序遍历的顺序是：左子树 -> 根节点 -> 右子树。也就是说，先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。

遍历过程：

中序遍历左子树（D、B、G、E）。与前序遍历不同，中序遍历不先导出根节点。一直搜索左节点直至第一个叶子节点。

然后访问该叶子节点的父节点，并导出。最后访问该父节点的右节点，但不直接导出。以此访问该节点的左右节点。
访问根节点A。
中序遍历右子树（C、F）。

在这里插入图片描述

遍历结果：D -> B -> G -> E -> A -> C -> F

3. 后序遍历（Postorder Traversal）

后序遍历的顺序是：左子树 -> 右子树 -> 根节点。也就是说，先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。

遍历过程：
1.根节点在最后访问！！！后序遍历左子树（D、G、E、B）。
在这里插入图片描述

然后访问该叶子节点的父节点的右节点（不绕不绕），但不直接导出。

后序遍历右子树（F、C）。
访问根节点A。

遍历结果：D -> G -> E -> B -> F -> C -> A

C++代码实现

下面我们通过C++代码来实现这三种遍历方法。首先，我们需要定义一个二叉树节点的结构体，然后实现前序、中序和后序遍历的函数。

#include <iostream>
using namespace std;

// 定义二叉树节点结构体
struct TreeNode {
    char data;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char val) : data(val), left(nullptr), right(nullptr) {}
};

// 前序遍历
void preorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    cout << root->data << " ";  // 访问根节点
    preorderTraversal(root->left);  // 递归遍历左子树
    preorderTraversal(root->right);  // 递归遍历右子树
}

// 中序遍历
void inorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    inorderTraversal(root->left);  // 递归遍历左子树
    cout << root->data << " ";  // 访问根节点
    inorderTraversal(root->right);  // 递归遍历右子树
}

// 后序遍历
void postorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    postorderTraversal(root->left);  // 递归遍历左子树
    postorderTraversal(root->right);  // 递归遍历右子树
    cout << root->data << " ";  // 访问根节点
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode('A');
    root->left = new TreeNode('B');
    root->right = new TreeNode('C');
    root->left->left = new TreeNode('D');
    root->left->right = new TreeNode('E');
    root->left->right->left = new TreeNode('G');
    root->right->right = new TreeNode('F');

    // 前序遍历
    cout << "前序遍历: ";
    preorderTraversal(root);
    cout << endl;

    // 中序遍历
    cout << "中序遍历: ";
    inorderTraversal(root);
    cout << endl;

    // 后序遍历
    cout << "后序遍历: ";
    postorderTraversal(root);
    cout << endl;

    return 0;
}

输出结果：

前序遍历: A B D E G C F 
中序遍历: D B G E A C F 
后序遍历: D G E B F C A

具体实例

假设我们有以下二叉树：

根据上述代码，我们可以得到以下遍历结果：

遍历方法	遍历顺序
前序遍历	A -> B -> D -> E -> G -> C -> F
中序遍历	D -> B -> G -> E -> A -> C -> F
后序遍历	D -> G -> E -> B -> F -> C -> A

二叉树进阶：常见操作全解析：插入、删除、查找、判断相等等

1. 二叉树节点的定义

首先，我们需要定义一个二叉树节点的结构体，包含节点的值、左子节点和右子节点。

#include <iostream>
using namespace std;

// 定义二叉树节点结构体
struct TreeNode {
    int value;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
};

2. 插入节点

插入节点的操作是根据二叉搜索树（BST）的性质进行的：左子节点的值小于根节点，右子节点的值大于根节点。

// 插入节点
TreeNode* insert(TreeNode* root, int value) {
    if (root == nullptr) {
        return new TreeNode(value); // 如果当前节点为空，创建新节点
    }
    if (value < root->value) {
        root->left = insert(root->left, value); // 递归插入左子树
    } else {
        root->right = insert(root->right, value); // 递归插入右子树
    }
    return root;
}

3. 删除节点

删除节点的操作需要处理三种情况：

要删除的节点是叶子节点。
要删除的节点有一个子节点。
要删除的节点有两个子节点。

// 删除节点
TreeNode* deleteNode(TreeNode* root, int value) {
    if (root == nullptr) return root; // 如果树为空，直接返回

    // 递归查找要删除的节点
    if (value < root->value) {
        root->left = deleteNode(root->left, value);
    } else if (value > root->value) {
        root->right = deleteNode(root->right, value);
    } else {
        // 找到要删除的节点
        if (root->left == nullptr) {
            // 只有右子节点
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            // 只有左子节点
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }
        // 有两个子节点的情况
        TreeNode* temp = root->right;
        while (temp && temp->left != nullptr) {
            temp = temp->left; // 找到右子树中的最小值节点
        }
        root->value = temp->value; // 用最小值节点的值替换当前节点
        root->right = deleteNode(root->right, temp->value); // 删除右子树中的最小值节点
    }
    return root;
}

4. 查找节点

查找节点的操作也是基于二叉搜索树的性质，递归地在左子树或右子树中查找目标值。

// 查找节点
TreeNode* search(TreeNode* root, int value) {
    if (root == nullptr || root->value == value) {
        return root; // 找到目标节点或树为空
    }
    if (value < root->value) {
        return search(root->left, value); // 递归查找左子树
    } else {
        return search(root->right, value); // 递归查找右子树
    }
}

5. 判断两棵二叉树是否相等

判断两棵二叉树是否相等，需要递归地比较每个节点的值和左右子树。

// 判断两棵二叉树是否相等
bool isSameTree(TreeNode* p, TreeNode* q) {
    if (p == nullptr && q == nullptr) return true; // 两棵树都为空
    if (p == nullptr || q == nullptr) return false; // 一棵树为空，另一棵不为空
    if (p->value != q->value) return false; // 节点值不相等
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right); // 递归比较左右子树
}

6. 计算二叉树的深度

二叉树的深度是从根节点到最远叶子节点的最长路径长度。

// 计算二叉树的深度
int maxDepth(TreeNode* root) {
    if (root == nullptr) return 0; // 空树的深度为0
    int leftDepth = maxDepth(root->left); // 计算左子树的深度
    int rightDepth = maxDepth(root->right); // 计算右子树的深度
    return max(leftDepth, rightDepth) + 1; // 返回较大值加1
}

7. 判断二叉树是否平衡

平衡二叉树是指每个节点的左右子树高度差不超过1。

// 判断二叉树是否平衡
bool isBalanced(TreeNode* root) {
    if (root == nullptr) return true; // 空树是平衡的
    int leftDepth = maxDepth(root->left); // 计算左子树深度
    int rightDepth = maxDepth(root->right); // 计算右子树深度
    if (abs(leftDepth - rightDepth) > 1) return false; // 高度差超过1，不平衡
    return isBalanced(root->left) && isBalanced(root->right); // 递归判断左右子树
}

8. 完整代码示例

以下是一个完整的C++程序，包含上述所有操作：

#include <iostream>
#include <algorithm> // 用于max和abs函数
using namespace std;

// 定义二叉树节点结构体
struct TreeNode {
    int value;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
};

// 插入节点
TreeNode* insert(TreeNode* root, int value) {
    if (root == nullptr) {
        return new TreeNode(value);
    }
    if (value < root->value) {
        root->left = insert(root->left, value);
    } else {
        root->right = insert(root->right, value);
    }
    return root;
}

// 删除节点
TreeNode* deleteNode(TreeNode* root, int value) {
    if (root == nullptr) return root;
    if (value < root->value) {
        root->left = deleteNode(root->left, value);
    } else if (value > root->value) {
        root->right = deleteNode(root->right, value);
    } else {
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }
        TreeNode* temp = root->right;
        while (temp && temp->left != nullptr) {
            temp = temp->left;
        }
        root->value = temp->value;
        root->right = deleteNode(root->right, temp->value);
    }
    return root;
}

// 查找节点
TreeNode* search(TreeNode* root, int value) {
    if (root == nullptr || root->value == value) {
        return root;
    }
    if (value < root->value) {
        return search(root->left, value);
    } else {
        return search(root->right, value);
    }
}

// 判断两棵二叉树是否相等
bool isSameTree(TreeNode* p, TreeNode* q) {
    if (p == nullptr && q == nullptr) return true;
    if (p == nullptr || q == nullptr) return false;
    if (p->value != q->value) return false;
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

// 计算二叉树的深度
int maxDepth(TreeNode* root) {
    if (root == nullptr) return 0;
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    return max(leftDepth, rightDepth) + 1;
}

// 判断二叉树是否平衡
bool isBalanced(TreeNode* root) {
    if (root == nullptr) return true;
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    if (abs(leftDepth - rightDepth) > 1) return false;
    return isBalanced(root->left) && isBalanced(root->right);
}

// 测试代码
int main() {
    TreeNode* root = nullptr;
    root = insert(root, 10);
    root = insert(root, 5);
    root = insert(root, 15);
    root = insert(root, 3);
    root = insert(root, 7);

    cout << "二叉树深度: " << maxDepth(root) << endl;
    cout << "二叉树是否平衡: " << (isBalanced(root) ? "是" : "否") << endl;

    root = deleteNode(root, 5);
    cout << "删除节点5后，二叉树深度: " << maxDepth(root) << endl;

    return 0;
}

总结

通过本文的介绍，我们了解了二叉树的基本概念以及三种常见的遍历方法：前序遍历、中序遍历和后序遍历。我们还通过C++代码实现了这三种遍历方法，并通过一个具体的实例展示了遍历的过程和结果。希望本文能帮助你更好地理解二叉树的遍历方法，并在实际编程中灵活运用。同时本文详细介绍了二叉树的常见操作，包括插入、删除、查找、判断相等等，并提供了可直接运行的C++代码示例。通过这些操作，你可以更好地理解和应用二叉树数据结构。希望本文对你有所帮助！如果有任何问题或建议，欢迎在评论区讨论。

如果你对二叉树的其他操作（如插入、删除、查找等）感兴趣，欢迎在评论区留言，我会在后续的文章中继续分享相关内容。

希望这篇博文对你有所帮助！如果有任何问题或建议，欢迎在评论区讨论。看懂了的话点个赞吧！

二编：反过来，如何通过前序遍历和中序遍历，中序遍历和后序遍历得出二叉树结构呢，关注博文：每日一题：通过前序与中序遍历、中序与后序遍历构造二叉树，带你进一步了解二叉树

题目介绍

从前序与中序遍历构造二叉树
给定一棵二叉树的前序遍历和中序遍历，构造这棵二叉树。
注意：树中不存在重复的节点。

示例：
输入：[1,2,3],[2,3,1]
输出：{1,2,#,#,3}

    1
   / 
  2
   \
    3

从中序与后序遍历构造二叉树
给定一棵二叉树的中序遍历和后序遍历，构造这棵二叉树。
注意：树中不存在重复的节点。

示例：
输入：[2,1,3],[2,3,1]
输出：{1,2,3}

    1
   / \
  2   3