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

以下是基于题目要求的C++代码实现：

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

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

// 初始化随机数
void initRandom(int arr[], int n) {
    srand(time(0));
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 100 + 1;
    }
}

// 简单选择排序
void simpleSelectSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            swap(arr[i], arr[minIndex]);
        }
    }
}

// 顺序查找
int sequentialSearch(int arr[], int n, int key) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == key) {
            return i;
        }
    }
    return -1;
}

// 折半查找
int binarySearch(int arr[], int n, int key) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == key) {
            return mid;
        } else if (arr[mid] > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
}

// 创建二叉排序树
void createBST(BSTNode*& root, int arr[], int n) {
    for (int i = 0; i < n; i++) {
        BSTNode* newNode = new BSTNode;
        newNode->data = arr[i];
        newNode->left = newNode->right = NULL;
        if (root == NULL) {
            root = newNode;
        } else {
            BSTNode* p = root;
            while (true) {
                if (arr[i] < p->data) {
                    if (p->left == NULL) {
                        p->left = newNode;
                        break;
                    } else {
                        p = p->left;
                    }
                } else {
                    if (p->right == NULL) {
                        p->right = newNode;
                        break;
                    } else {
                        p = p->right;
                    }
                }
            }
        }
    }
}

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

int main() {
    const int N = 10000;
    const int M = 1000;
    int arr[N];
    initRandom(arr, N);
    simpleSelectSort(arr, N);

    int searchArr[M];
    initRandom(searchArr, M);

    clock_t start, end;
    double duration;

    // 顺序查找
    start = clock();
    for (int i = 0; i < M; i++) {
        sequentialSearch(arr, N, searchArr[i]);
    }
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    cout << "Sequential search time: " << duration << "s" << endl;

    // 折半查找
    start = clock();
    for (int i = 0; i < M; i++) {
        binarySearch(arr, N, searchArr[i]);
    }
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    cout << "Binary search time: " << duration << "s" << endl;

    // 创建二叉排序树
    BSTNode* root = NULL;
    createBST(root, arr, N);

    // 二叉排序树查找
    start = clock();
    for (int i = 0; i < M; i++) {
        BSTSearch(root, searchArr[i]);
    }
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    cout << "Binary search tree time: " << duration << "s" << endl;

    return 0;
}

在上述代码中，我们首先使用 `initRandom` 初始化一个包含 N 个随机数的数组，然后使用 `simpleSelectSort` 对该数组进行简单选择排序。接着，我们使用 `sequentialSearch` 进行顺序查找、`binarySearch` 进行折半查找、`createBST` 创建二叉排序树、`BSTSearch` 对二叉排序树进行查找，最后使用 `clock` 函数获取每个查找算法耗费的时间。