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

好的，根据您的要求，我会回答您的问题并为您提供代码实现。

首先，我们来定义二叉排序树的抽象数据类型：

typedef struct BSTNode {
    int data;  // 节点数据
    struct BSTNode* left;  // 左子树指针
    struct BSTNode* right;  // 右子树指针
} BSTNode, *BSTree;

接下来，我们来实现二叉排序树的基本操作：

1. 建立二叉排序树

void createBSTree(BSTree* tree, int* data, int n) {
    *tree = NULL;  // 初始化树为空
    for (int i = 0; i < n; i++) {
        insertBSTree(tree, data[i]);  // 依次插入数据建树
    }
}

2. 查找节点

BSTNode* searchBSTree(BSTree tree, int key) {
    if (tree == NULL || tree->data == key) {
        return tree;  // 如果树为空或者当前节点就是要查找的节点，直接返回
    }
    if (key < tree->data) {
        return searchBSTree(tree->left, key);  // 如果要查找的节点比当前节点小，就在左子树中递归查找
    } else {
        return searchBSTree(tree->right, key);  // 如果要查找的节点比当前节点大，就在右子树中递归查找
    }
}

3. 插入节点

void insertBSTree(BSTree* tree, int key) {
    if (*tree == NULL) {
        *tree = (BSTNode*)malloc(sizeof(BSTNode));  // 如果树为空，就创建一个新节点插入
        (*tree)->data = key;
        (*tree)->left = NULL;
        (*tree)->right = NULL;
    } else if (key < (*tree)->data) {
        insertBSTree(&(*tree)->left, key);  // 如果要插入的节点比当前节点小，就递归插入左子树
    } else if (key > (*tree)->data) {
        insertBSTree(&(*tree)->right, key);  // 如果要插入的节点比当前节点大，就递归插入右子树
    }
}

4. 删除节点

void deleteBSTree(BSTree* tree, int key) {
    if (*tree == NULL) {
        return;  // 如果树为空，直接返回
    }
    if (key < (*tree)->data) {
        deleteBSTree(&(*tree)->left, key);  // 如果要删除的节点比当前节点小，就递归删除左子树
    } else if (key > (*tree)->data) {
        deleteBSTree(&(*tree)->right, key);  // 如果要删除的节点比当前节点大，就递归删除右子树
    } else {
        if ((*tree)->left != NULL && (*tree)->right != NULL) {
            // 如果要删除的节点既有左子树又有右子树
            BSTNode* p = (*tree)->right;
            while (p->left != NULL) {
                p = p->left;  // 找到右子树中的最小节点
            }
            (*tree)->data = p->data;  // 把右子树中的最小节点的值赋值给当前节点
            deleteBSTree(&(*tree)->right, p->data);  // 在右子树中删除最小节点
        } else {
            BSTNode* temp = *tree;
            if ((*tree)->left == NULL) {
                *tree = (*tree)->right;  // 如果只有右子树或者没有子树，就把右子树或者NULL赋值给当前节点
            } else {
                *tree = (*tree)->left;  // 如果只有左子树，就把左子树赋值给当前节点
            }
            free(temp);  // 释放被删除的节点的内存空间
        }
    }
}

5. 销毁二叉排序树

void destroyBSTree(BSTree* tree) {
    if (*tree == NULL) {
        return;  // 如果树为空，直接返回
    }
    if ((*tree)->left != NULL) {
        destroyBSTree(&(*tree)->left);  // 递归销毁左子树
    }
    if ((*tree)->right != NULL) {
        destroyBSTree(&(*tree)->right);  // 递归销毁右子树
    }
    free(*tree);  // 释放当前节点的内存空间
    *tree = NULL;  // 把当前节点指针赋值为NULL
}

最后，我们来编写测试main()函数测试算法的正确性：

int main() {
    int data[] = {8, 3, 10, 1, 6, 14, 4, 7, 13};
    int n = sizeof(data) / sizeof(data[0]);
    BSTree tree;
    createBSTree(&tree, data, n);

    printf("Original tree:\n");
    printBSTree(tree);

    int key = 6;
    BSTNode* node = searchBSTree(tree, key);
    if (node != NULL) {
        printf("The node with key %d exists in the tree.\n", key);
    } else {
        printf("The node with key %d does not exist in the tree.\n", key);
    }

    key = 5;
    insertBSTree(&tree, key);
    printf("Tree after inserting node with key %d:\n", key);
    printBSTree(tree);

    key = 10;
    deleteBSTree(&tree, key);
    printf("Tree after deleting node with key %d:\n", key);
    printBSTree(tree);

    destroyBSTree(&tree);

    return 0;
}

完整代码如下：