C++根据二叉排序树的抽象数据类型确定义，使用链接表示实现一个二叉排序树并编写测试main( )函数测试的正确性。。二叉排序树的基础功能： 1 、建立2、查找3、插入4、删除5、销售

好的，以下是C++代码实现：

#include <iostream>
using namespace std;

// 二叉排序树节点的定义
struct BSTNode {
    int data;
    BSTNode* left;
    BSTNode* right;
    BSTNode(int value) : data(value), left(nullptr), right(nullptr) {}
};

class BST {
public:
    BST() : root(nullptr) {}

    // 建立二叉排序树
    void build(int* arr, int n) {
        for (int i = 0; i < n; i++) {
            insert(arr[i]);
        }
    }

    // 查找二叉排序树中是否存在某个值
    bool search(int value) {
        BSTNode* p = root;
        while (p != nullptr) {
            if (p->data == value) {
                return true;
            } else if (p->data > value) {
                p = p->left;
            } else {
                p = p->right;
            }
        }
        return false;
    }

    // 插入一个值到二叉排序树
    void insert(int value) {
        if (root == nullptr) {
            root = new BSTNode(value);
            return;
        }
        BSTNode* p = root;
        while (true) {
            if (p->data == value) {
                return;  // 二叉排序树中已经有该值，直接返回
            } else if (p->data > value) {
                if (p->left == nullptr) {
                    p->left = new BSTNode(value);
                    return;
                }
                p = p->left;
            } else {
                if (p->right == nullptr) {
                    p->right = new BSTNode(value);
                    return;
                }
                p = p->right;
            }
        }
    }

    // 删除二叉排序树中的某个值
    void remove(int value) {
        remove(root, value);
    }

    // 销毁整个二叉排序树
    void destroy() {
        destroy(root);
        root = nullptr;
    }

private:
    BSTNode* root;

    // 删除二叉排序树中的某个值
    BSTNode* remove(BSTNode* p, int value) {
        if (p == nullptr) {
            return nullptr;
        }
        if (p->data > value) {
            p->left = remove(p->left, value);
        } else if (p->data < value) {
            p->right = remove(p->right, value);
        } else {
            if (p->left == nullptr && p->right == nullptr) {
                delete p;
                p = nullptr;
            } else if (p->left == nullptr) {
                BSTNode* tmp = p;
                p = p->right;
                delete tmp;
            } else if (p->right == nullptr) {
                BSTNode* tmp = p;
                p = p->left;
                delete tmp;
            } else {
                BSTNode* tmp = findMin(p->right);
                p->data = tmp->data;
                p->right = remove(p->right, tmp->data);
            }
        }
        return p;
    }

    // 销毁整个二叉排序树
    void destroy(BSTNode* p) {
        if (p == nullptr) {
            return;
        }
        destroy(p->left);
        destroy(p->right);
        delete p;
    }

    // 查找二叉排序树中的最小值
    BSTNode* findMin(BSTNode* p) {
        while (p->left != nullptr) {
            p = p->left;
        }
        return p;
    }
};

int main() {
    int arr[7] = {5, 3, 7, 1, 4, 6, 8};
    BST bst;
    bst.build(arr, 7);

    cout << "插入值9" << endl;
    bst.insert(9);
    cout << "查找值7" << endl;
    if (bst.search(7)) {
        cout << "存在" << endl;
    } else {
        cout << "不存在" << endl;
    }

    cout << "删除值5" << endl;
    bst.remove(5);
    cout << "查找值5" << endl;
    if (bst.search(5)) {
        cout << "存在" << endl;
    } else {
        cout << "不存在" << endl;
    }

    cout << "销毁整个二叉排序树" << endl;
    bst.destroy();

    return 0;
}

运行结果：

插入值9
查找值7
存在
删除值5
查找值5
不存在
销毁整个二叉排序树