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

好的，根据您的要求，我将回答您的问题。以下是使用链表实现二叉排序树的代码：

#include <iostream>
using namespace std;

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

class BinarySearchTree {
private:
    TreeNode* root;

    TreeNode* insert(TreeNode* root, int val) {
        if (root == NULL) {
            root = new TreeNode(val);
            return root;
        }
        if (val < root->val) {
            root->left = insert(root->left, val);
        }
        else if (val > root->val) {
            root->right = insert(root->right, val);
        }
        return root;
    }

    TreeNode* search(TreeNode* root, int val) {
        if (root == NULL || root->val == val) {
            return root;
        }
        if (val < root->val) {
            return search(root->left, val);
        }
        else {
            return search(root->right, val);
        }
    }

    TreeNode* minValueNode(TreeNode* node) {
        TreeNode* current = node;
        while (current->left != NULL) {
            current = current->left;
        }
        return current;
    }

    TreeNode* deleteNode(TreeNode* root, int val) {
        if (root == NULL) {
            return root;
        }
        if (val < root->val) {
            root->left = deleteNode(root->left, val);
        }
        else if (val > root->val) {
            root->right = deleteNode(root->right, val);
        }
        else {
            if (root->left == NULL) {
                TreeNode* temp = root->right;
                delete root;
                return temp;
            }
            else if (root->right == NULL) {
                TreeNode* temp = root->left;
                delete root;
                return temp;
            }
            TreeNode* temp = minValueNode(root->right);
            root->val = temp->val;
            root->right = deleteNode(root->right, temp->val);
        }
        return root;
    }

    void destroy(TreeNode* root) {
        if (root != NULL) {
            destroy(root->left);
            destroy(root->right);
            delete root;
        }
    }

public:
    BinarySearchTree() {
        root = NULL;
    }

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

    TreeNode* search(int val) {
        return search(root, val);
    }

    void deleteNode(int val) {
        root = deleteNode(root, val);
    }

    void destroy() {
        destroy(root);
        root = NULL;
    }
};

int main() {
    BinarySearchTree bst;
    bst.insert(5);
    bst.insert(3);
    bst.insert(7);
    bst.insert(1);
    bst.insert(9);
    TreeNode* node1 = bst.search(3);
    if (node1 != NULL) {
        cout << "Node 3 found!" << endl;
    }
    else {
        cout << "Node 3 not found!" << endl;
    }
    TreeNode* node2 = bst.search(6);
    if (node2 != NULL) {
        cout << "Node 6 found!" << endl;
    }
    else {
        cout << "Node 6 not found!" << endl;
    }
    bst.deleteNode(5);
    TreeNode* node3 = bst.search(5);
    if (node3 != NULL) {
        cout << "Node 5 found!" << endl;
    }
    else {
        cout << "Node 5 not found!" << endl;
    }
    bst.destroy();
    return 0;
}

以上代码中，我们定义了一个 `TreeNode` 结构体，包含 `val` 值，以及指向左右子节点的指针。接着，我们定义了一个 `BinarySearchTree` 类，包含了建立、查找、插入、删除和销毁二叉排序树的方法。其中，插入、查找和删除方法都是递归实现的。

在 `main()` 函数中，我们首先建立了一个二叉排序树，并插入了一些节点。然后，我们使用 `search()` 方法查找节点 `3` 和节点 `6`，并输出结果。接着，我们使用 `deleteNode()` 方法删除了节点 `5`，并再次使用 `search()` 方法查找节点 `5`，并输出结果。最后，我们使用 `destroy()` 方法销毁了整个二叉排序树。

希望这个代码可以满足您的需求，如有疑问，可以继续向我提问。