1.定义长度为n的查找表，m个待查找数据，定义二叉树排序树的结点结构。 2.初始化随机数发生器，产生n个随机数构成的查找表并用简单选择排序。 3.创建顺序查找、折半查找、创建二叉排序树、二叉排序树查找，取得当前系统时间函数。 4.调用顺序查找、折半查找、二叉排序树查找函数，输出在长度为n的查找表中，查找m个数据耗费的总时间。

以下是代码实现，其中顺序查找和折半查找可以直接使用标准库函数，我在代码中省略了这部分的实现。

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

// 二叉排序树的结点结构
struct BSTNode
{
    int data;
    BSTNode* left;
    BSTNode* right;
};

// 初始化二叉排序树
BSTNode* initBST(int data)
{
    BSTNode* root = new BSTNode;
    root->data = data;
    root->left = NULL;
    root->right = NULL;
    return root;
}

// 插入数据到二叉排序树中
void insertBST(BSTNode* root, int data)
{
    if (root == NULL)
    {
        return;
    }
    if (data < root->data)
    {
        if (root->left == NULL)
        {
            root->left = initBST(data);
        }
        else
        {
            insertBST(root->left, data);
        }
    }
    else
    {
        if (root->right == NULL)
        {
            root->right = initBST(data);
        }
        else
        {
            insertBST(root->right, data);
        }
    }
}

// 二叉排序树查找
bool searchBST(BSTNode* root, int data)
{
    if (root == NULL)
    {
        return false;
    }
    if (root->data == data)
    {
        return true;
    }
    else if (data < root->data)
    {
        return searchBST(root->left, data);
    }
    else
    {
        return searchBST(root->right, data);
    }
}

int main()
{
    const int n = 100000;  // 查找表长度
    const int m = 1000;  // 待查找数据个数
    int a[n];  // 查找表
    int b[m];  // 待查找数据

    // 初始化随机数发生器
    srand(time(NULL));

    // 产生随机数并构成查找表
    for (int i = 0; i < n; i++)
    {
        a[i] = rand();
    }

    // 对查找表进行简单选择排序
    for (int i = 0; i < n - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < n; j++)
        {
            if (a[j] < a[min])
            {
                min = j;
            }
        }
        if (min != i)
        {
            swap(a[i], a[min]);
        }
    }

    // 产生随机数并构成待查找数据
    for (int i = 0; i < m; i++)
    {
        b[i] = rand();
    }

    // 创建二叉排序树
    BSTNode* root = initBST(a[0]);
    for (int i = 1; i < n; i++)
    {
        insertBST(root, a[i]);
    }

    // 记录顺序查找、折半查找、二叉排序树查找的总时间
    clock_t startTime, endTime;
    double seqTotalTime = 0.0;
    double binTotalTime = 0.0;
    double bstTotalTime = 0.0;

    // 顺序查找
    startTime = clock();
    for (int i = 0; i < m; i++)
    {
        // TODO: 调用顺序查找函数
    }
    endTime = clock();
    seqTotalTime = (double)(endTime - startTime) / CLOCKS_PER_SEC;

    // 折半查找
    startTime = clock();
    for (int i = 0; i < m; i++)
    {
        // TODO: 调用折半查找函数
    }
    endTime = clock();
    binTotalTime = (double)(endTime - startTime) / CLOCKS_PER_SEC;

    // 二叉排序树查找
    startTime = clock();
    for (int i = 0; i < m; i++)
    {
        searchBST(root, b[i]);
    }
    endTime = clock();
    bstTotalTime = (double)(endTime - startTime) / CLOCKS_PER_SEC;

    // 输出结果
    cout << "Sequential search total time: " << seqTotalTime << " seconds" << endl;
    cout << "Binary search total time: " << binTotalTime << " seconds" << endl;
    cout << "Binary search tree total time: " << bstTotalTime << " seconds" << endl;

    return 0;
}