线性表基本操作的实现，通过简单实例测试各基本操作函数算法的正确性。要求基本操作包括：初始化、销毁、建表、清空、判空、求表长、遍历、取值、插入、删除、查找

线性表是一种常见的数据结构，包括顺序表和链表两种实现方式。基本操作包括初始化、销毁、建表、清空、判空、求表长、遍历、取值、插入、删除、查找等。

下面以顺序表为例，简单介绍各基本操作函数的实现和测试方法：

1. 初始化：初始化操作是为线性表分配内存空间，并将表头指针指向该空间。实现方式如下：

void InitList(SqList &L) {
    L.elem = new ElemType[MAXSIZE];
    L.length = 0;
}

其中，SqList是顺序表类型，MAXSIZE是表的最大长度，ElemType是表中元素的类型。初始化后，表长为0。

2. 销毁：销毁操作是释放线性表占用的内存空间。实现方式如下：

void DestroyList(SqList &L) {
    delete[] L.elem;
    L.length = 0;
}

3. 建表：建表操作是将一组元素按照一定顺序存储到线性表中。实现方式如下：

void CreateList(SqList &L, ElemType a[], int n) {
    for (int i = 0; i < n; i++) {
        L.elem[i] = a[i];
    }
    L.length = n;
}

其中，a[]是待插入的元素数组，n是数组长度。建表后，线性表中的元素顺序与数组中的元素顺序相同。

4. 清空：清空操作是将线性表中的元素全部删除，表长为0。实现方式如下：

void ClearList(SqList &L) {
    L.length = 0;
}

5. 判空：判空操作是判断线性表是否为空表。实现方式如下：

bool ListEmpty(SqList L) {
    return L.length == 0;
}

6. 求表长：求表长操作是返回线性表中元素的个数。实现方式如下：

int ListLength(SqList L) {
    return L.length;
}

7. 遍历：遍历操作是依次访问线性表中的每个元素。实现方式如下：

void ListTraverse(SqList L) {
    for (int i = 0; i < L.length; i++) {
        cout << L.elem[i] << " ";
    }
    cout << endl;
}

8. 取值：取值操作是返回线性表中指定位置的元素值。实现方式如下：

bool GetElem(SqList L, int i, ElemType &e) {
    if (i < 1 || i > L.length) {
        return false;
    }
    e = L.elem[i - 1];
    return true;
}

其中，i是元素在表中的位置，e是返回的元素值。如果i越界，则返回false。

9. 插入：插入操作是在线性表中指定位置插入一个元素。实现方式如下：

bool ListInsert(SqList &L, int i, ElemType e) {
    if (i < 1 || i > L.length + 1 || L.length == MAXSIZE) {
        return false;
    }
    for (int j = L.length; j >= i; j--) {
        L.elem[j] = L.elem[j - 1];
    }
    L.elem[i - 1] = e;
    L.length++;
    return true;
}

其中，i是插入位置，e是待插入元素。如果i越界或表满，则返回false。

10. 删除：删除操作是删除线性表中指定位置的元素。实现方式如下：

bool ListDelete(SqList &L, int i, ElemType &e) {
    if (i < 1 || i > L.length) {
        return false;
    }
    e = L.elem[i - 1];
    for (int j = i; j < L.length; j++) {
        L.elem[j - 1] = L.elem[j];
    }
    L.length--;
    return true;
}

其中，i是删除位置，e是被删除的元素值。如果i越界，则返回false。

11. 查找：查找操作是在线性表中查找指定元素值的位置。实现方式如下：

int LocateElem(SqList L, ElemType e) {
    for (int i = 0; i < L.length; i++) {
        if (L.elem[i] == e) {
            return i + 1;
        }
    }
    return 0;
}

其中，e是待查找的元素值。如果找到，则返回元素在表中的位置，否则返回0。

以上是顺序表的基本操作函数实现方式。为测试各函数算法的正确性，可以编写一个简单的主函数，调用各函数并输出结果。例如：

int main() {
    SqList L;
    ElemType a[] = {1, 2, 3, 4, 5};
    InitList(L);
    CreateList(L, a, 5);
    ListTraverse(L);
    int len = ListLength(L);
    cout << "Length: " << len << endl;
    bool empty = ListEmpty(L);
    cout << "Empty: " << empty << endl;
    ElemType e;
    GetElem(L, 3, e);
    cout << "GetElem: " << e << endl;
    ListInsert(L, 2, 6);
    ListTraverse(L);
    ListDelete(L, 4, e);
    ListTraverse(L);
    int pos = LocateElem(L, 3);
    cout << "LocateElem: " << pos << endl;
    DestroyList(L);
    return 0;
}

输出结果为：

1 2 3 4 5 
Length: 5
Empty: 0
GetElem: 3
1 6 2 3 4 5 
1 6 2 4 5 
LocateElem: 3

可以看到，各函数的算法实现正确，符合预期结果。