二叉查找树操作和遍历

#include <iostream>

using namespace std;

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

class BinaryTree {
public:
    TreeNode* root;

    // 构造函数
    BinaryTree() : root(nullptr) {}

    // 创建二叉树节点
    TreeNode* insert(TreeNode* node, int val) {
        if (node == nullptr) {
            return new TreeNode(val);
        }
        if (val < node->val) {
            node->left = insert(node->left, val);
        } else if (val > node->val) {
            node->right = insert(node->right, val);
        }
        return node;
    }

    // 删除节点
    TreeNode* remove(TreeNode* node, int val) {
        if (node == nullptr) return node;
        if (val < node->val) {
            node->left = remove(node->left, val);
        } else if (val > node->val) {
            node->right = remove(node->right, val);
        } else {
            if (node->left == nullptr) {
                TreeNode* temp = node->right;
                delete node;
                return temp;
            } else if (node->right == nullptr) {
                TreeNode* temp = node->left;
                delete node;
                return temp;
            }
            TreeNode* temp = findMinNode(node->right);
            node->val = temp->val;
            node->right = remove(node->right, temp->val);
        }
        return node;
    }

    // 查找最小值节点
    TreeNode* findMinNode(TreeNode* node) {
        TreeNode* current = node;
        while (current && current->left != nullptr)
            current = current->left;
        return current;
    }

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

    // 更新节点值
    void updateValue(TreeNode* node, int oldVal, int newVal) {
        if (node->val == oldVal) {
            node->val = newVal;
        } else if (oldVal < node->val) {
            updateValue(node->left, oldVal, newVal);
        } else {
            updateValue(node->right, oldVal, newVal);
        }
    }

    // 中序遍历
    void inorderTraversal(TreeNode* node) {
        if (node != nullptr) {
            inorderTraversal(node->left);
            cout << node->val << " ";
            inorderTraversal(node->right);
        }
    }

    // 先序遍历
    void preorderTraversal(TreeNode* node) {
        if (node != nullptr) {
            cout << node->val << " ";
            preorderTraversal(node->left);
            preorderTraversal(node->right);
        }
    }

    // 后序遍历
    void postorderTraversal(TreeNode* node) {
        if (node != nullptr) {
            postorderTraversal(node->left);
            postorderTraversal(node->right);
            cout << node->val << " ";
        }
    }
};

int main() {
    BinaryTree tree;
    tree.root = tree.insert(tree.root, 5);
    tree.root = tree.insert(tree.root, 3);
    tree.root = tree.insert(tree.root, 7);
    tree.root = tree.insert(tree.root, 2);
    tree.root = tree.insert(tree.root, 4);
    tree.root = tree.insert(tree.root, 6);
    tree.root = tree.insert(tree.root, 8);

    cout << "Inorder traversal: ";
    tree.inorderTraversal(tree.root);
    cout << endl;

    cout << "Preorder traversal: ";
    tree.preorderTraversal(tree.root);
    cout << endl;

    cout << "Postorder traversal: ";
    tree.postorderTraversal(tree.root);
    cout << endl;

    // 删除节点
    tree.root = tree.remove(tree.root, 3);
    cout << "Inorder traversal after deleting 3: ";
    tree.inorderTraversal(tree.root);
    cout << endl;

    // 查找节点
    TreeNode* foundNode = tree.search(tree.root, 7);
    if (foundNode != nullptr) {
        cout << "Node with value 7 found." << endl;
    } else {
        cout << "Node with value 7 not found." << endl;
    }

    // 更新节点值
    tree.updateValue(tree.root, 7, 17);
    cout << "Inorder traversal after updating 7 to 17: ";
    tree.inorderTraversal(tree.root);
    cout << endl;

    return 0;
}