C++采用结构体类型描述查找表的存储结构，编写具体函数实现查找表的顺序查找和折半查找等基本操作

以下是C++代码实现查找表的顺序查找和折半查找基本操作：

#include <iostream>
using namespace std;

const int MAXSIZE = 100; //定义查找表最大长度

struct SeqList { //定义顺序表结构体
    int data[MAXSIZE]; //存放数据元素
    int length; //存放表长
};

//初始化顺序表
void InitList(SeqList &L) {
    L.length = 0;
}

//插入元素到顺序表中
bool ListInsert(SeqList &L, int i, int e) {
    if (i < 1 || i > L.length + 1 || L.length == MAXSIZE) {
        return false;
    }
    for (int j = L.length; j >= i; j--) {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;
    L.length++;
    return true;
}

//删除顺序表中第i个元素
bool ListDelete(SeqList &L, int i) {
    if (i < 1 || i > L.length) {
        return false;
    }
    for (int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

//顺序查找
int SeqSearch(SeqList L, int key) {
    int i;
    for (i = 0; i < L.length; i++) {
        if (L.data[i] == key) {
            return i + 1; //返回查找到的元素位置
        }
    }
    return 0; //未找到
}

//折半查找前提：表必须有序
int BinarySearch(SeqList L, int key) {
    int low = 0, high = L.length - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (L.data[mid] == key) {
            return mid + 1; //返回查找到的元素位置
        }
        else if (L.data[mid] > key) {
            high = mid - 1;
        }
        else {
            low = mid + 1;
        }
    }
    return 0; //未找到
}

int main() {
    SeqList L;
    InitList(L);

    //测试顺序查找
    ListInsert(L, 1, 10);
    ListInsert(L, 2, 20);
    ListInsert(L, 3, 30);
    ListInsert(L, 4, 40);
    ListInsert(L, 5, 50);
    int pos = SeqSearch(L, 30);
    if (pos) {
        cout << "顺序查找：找到了，位置是" << pos << endl;
    }
    else {
        cout << "顺序查找：没找到" << endl;
    }

    //测试折半查找
    ListInsert(L, 6, 60);
    ListInsert(L, 7, 70);
    ListInsert(L, 8, 80);
    ListInsert(L, 9, 90);
    ListInsert(L, 10, 100);
    int pos2 = BinarySearch(L, 80);
    if (pos2) {
        cout << "折半查找：找到了，位置是" << pos2 << endl;
    }
    else {
        cout << "折半查找：没找到" << endl;
    }
    return 0;
}

这里用结构体类型描述了顺序表的存储结构，实现了初始化顺序表、插入元素、删除元素、顺序查找和折半查找等基本操作。其中顺序查找的时间复杂度为O(n)，而折半查找的时间复杂度为O(logn)。