本关任务：编写一个函数实现线性表的清空。 函数原型：status ClearList(SqList &L) 功能说明：若线性表L不存在，返回INFEASIBLE。否则清空线性表L，返回OK；

好的，我来为您编写一个实现线性表清空的函数。

typedef int ElemType; // 定义线性表数据类型
typedef struct {
    ElemType *data; // 存储数据元素的一维数组
    int length; // 线性表当前长度
    int listsize; // 线性表最大长度
} SqList;

typedef enum {
    OK = 1,
    ERROR = 0,
    INFEASIBLE = -1
} status;

status ClearList(SqList &L) {
    if (L.data == NULL) { // 如果线性表为空，返回INFEASIBLE
        return INFEASIBLE;
    }
    L.length = 0; // 将线性表长度设置为0即可清空线性表
    return OK;
}

这个函数的实现比较简单，如果线性表为空，返回INFEASIBLE，否则将线性表长度设置为0即可清空线性表，最后返回OK。

相关问题

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

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

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

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

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

调试并理解线性表顺序存储的实现，如线性表结构定义，初始化，插入元素，删除元素，便利显示，清空

线性表顺序存储的实现是通过数组来实现的，其结构定义为：

typedef struct {
ElemType *data; // 存储数据的数组
int length; // 线性表长度
int maxSize; // 线性表最大容量
} SqList;

初始化线性表可以通过以下代码实现：

Status InitList(SqList *L, int maxSize) {
L->data = (ElemType*)malloc(maxSize * sizeof(ElemType));
if (!L->data) {
exit(OVERFLOW);
}
L->length = ;
L->maxSize = maxSize;
return OK;
}

插入元素可以通过以下代码实现：

Status ListInsert(SqList *L, int i, ElemType e) {
if (i < 1 || i > L->length + 1) {
return ERROR;
}
if (L->length >= L->maxSize) {
return ERROR;
}
for (int j = L->length; j >= i; j--) {
L->data[j] = L->data[j - 1];
}
L->data[i - 1] = e;
L->length++;
return OK;
}

删除元素可以通过以下代码实现：

Status ListDelete(SqList *L, int i, ElemType *e) {
if (i < 1 || i > L->length) {
return ERROR;
}
*e = L->data[i - 1];
for (int j = i; j < L->length; j++) {
L->data[j - 1] = L->data[j];
}
L->length--;
return OK;
}

遍历显示可以通过以下代码实现：

void ListTraverse(SqList L) {
for (int i = ; i < L.length; i++) {
printf("%d ", L.data[i]);
}
printf("\n");
}

清空线性表可以通过以下代码实现：

void ClearList(SqList *L) {
L->length = ;
}