二叉搜索树的简单C++类实现

二叉搜索树（BST）是一种重要的数据结构，它对于理解树的操作和算法至关重要，其中序输出是有序的。本文通过C++实现一个BST的类，并在插入和删除节点时提供清晰的输出，可视化这些操作的过程。

二叉搜索树的节点结构

首先定义一个TreeNode结构来表示树中的每个节点。每个节点包含一个整数值、一个指向左子节点的指针和一个指向右子节点的指针。

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

二叉搜索树类的实现

创建了一个BinarySearchTree类，它包含一个指向树根的指针和几个私有的递归辅助函数。这些函数用于实现插入、中序遍历和删除整棵树的操作。

class BinarySearchTree {
private:
    TreeNode *root;

    // 递归帮助函数，用于插入值
    TreeNode* insert(TreeNode *node, int value) {
        if (node == nullptr) {
            std::cout << "Inserted " << value << " into the BST.\n";
            return new TreeNode(value);
        }
        if (value < node->value) {
            std::cout << "Inserting " << value << " to the left of " << node->value << ".\n";
            node->left = insert(node->left, value);
        } else if (value > node->value) {
            std::cout << "Inserting " << value << " to the right of " << node->value << ".\n";
            node->right = insert(node->right, value);
        }
        return node;
    }

    // 递归帮助函数，用于中序遍历
    void inorderTraversal(TreeNode *node) const {
        if (node != nullptr) {
            inorderTraversal(node->left);
            std::cout << node->value << " ";
            inorderTraversal(node->right);
        }
    }

    // 递归帮助函数，用于删除树
    void deleteTree(TreeNode *node) {
        if (node != nullptr) {
            deleteTree(node->left);
            deleteTree(node->right);
            std::cout << "Deleting node with value: " << node->value << "\n";
            delete node;
        }
    }

public:
    BinarySearchTree() : root(nullptr) {}

    ~BinarySearchTree() {
        deleteTree(root);
    }

    void insert(int value) {
        root = insert(root, value);
    }

    void inorderTraversal() const {
        std::cout << "Inorder Traversal: ";
        inorderTraversal(root);
        std::cout << std::endl;
    }
};

插入操作

在insert函数中添加打印语句来显示插入过程。这些打印语句帮助我们可视化了插入的每一步。

中序遍历

中序遍历是一种遍历树的方法，它首先访问左子树，然后访问根节点，最后访问右子树。对于BST来说，中序遍历的结果是按排序顺序显示树中的所有值。

删除操作

在BinarySearchTree的析构函数中，我们实现了deleteTree函数来删除整棵树。在删除每个节点之前，我们打印出该节点的值。

主函数

在主函数中，我们创建了一个二叉搜索树实例，并插入了一些值。然后，我们执行了中序遍历来查看树的内容。

int main() {
    BinarySearchTree bst;

    // 插入元素
    bst.insert(5);
    bst.insert(3);
    bst.insert(7);
    bst.insert(2);
    bst.insert(4);
    bst.insert(6);
    bst.insert(8);

    // 中序遍历二叉搜索树
    bst.inorderTraversal();

    return 0;
}

结果分析

当我们运行上述程序时，控制台输出显示了插入节点的过程，并在程序结束时显示了删除节点的过程。

Inserted 5 into the BST.
Inserting 3 to the left of 5.
Inserted 3 into the BST.
Inserting 7 to the right of 5.
Inserted 7 into the BST.
Inserting 2 to the left of 5.
Inserting 2 to the left of 3.
Inserted 2 into the BST.
Inserting 4 to the left of 5.
Inserting 4 to the right of 3.
Inserted 4 into the BST.
Inserting 6 to the right of 5.
Inserting 6 to the left of 7.
Inserted 6 into the BST.
Inserting 8 to the right of 5.
Inserting 8 to the right of 7.
Inserted 8 into the BST.
Inorder Traversal: 2 3 4 5 6 7 8
Deleting node with value: 2
Deleting node with value: 4
Deleting node with value: 3
Deleting node with value: 6
Deleting node with value: 8
Deleting node with value: 7
Deleting node with value: 5

通过这些输出可以清楚地看到二叉搜索树在插入和删除节点时的行为。

不过要注意，这个示例没有实现删除单个节点的功能。在实际应用中，删除操作通常需要考虑多种不同的情况，并且可能需要重新平衡树以保持其性能。