帮我写一道题“请编写函数，删除线性表中所有与指定值相同的数据元素。 函数原型 void LListRemoveValue(LLIST *list, const LELEMENT *element); 说明：参数 list 是指示线性表(单链表)的指针，element 是指向数据元素的指针。函数将删除线性表中所有与指定值相同的数据元素。 修改主函数，对以上函数进行测试。 int main() { LELEMENT x; LLIST a; LListCreate(&a); LListInput(&a); LElementInput(&x); LListRemoveValue(&a, &x); LListOutput(&a); putchar('\n'); LListDestroy(&a); return 0; } 输入样例 ( 2.8, 4.7, 5.2, 2.8, 3.6, 2.8, 2.8, 5.2, 7.2, 2.8 ) 2.8 输出样例 ( 4.7, 5.2, 3.6, 5.2, 7.2 ) 要求：时间复杂度为 O(n)，空间复杂度为 O(1)。 代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB”

以下是题目所需的代码实现：

#include <stdio.h>
#include <stdlib.h>

// 定义数据元素的结构体
typedef struct {
    float data;
} LELEMENT;

// 定义链表结点的结构体
typedef struct node {
    LELEMENT element;
    struct node *next;
} NODE;

// 定义链表的结构体
typedef struct {
    NODE *head;
    int size;
} LLIST;

// 初始化链表
void LListCreate(LLIST *list) {
    list->head = NULL;
    list->size = 0;
}

// 在链表末尾添加结点
void LListAdd(LLIST *list, const LELEMENT *element) {
    NODE *node = (NODE *)malloc(sizeof(NODE));
    node->element = *element;
    node->next = NULL;

    if (list->head == NULL) {
        list->head = node;
    } else {
        NODE *tmp = list->head;
        while (tmp->next != NULL) {
            tmp = tmp->next;
        }
        tmp->next = node;
    }

    list->size++;
}

// 从链表中删除结点
void LListRemove(LLIST *list, NODE *prev, NODE *node) {
    if (prev == NULL) {
        list->head = node->next;
    } else {
        prev->next = node->next;
    }
    free(node);
    list->size--;
}

// 删除链表中所有与指定值相同的结点
void LListRemoveValue(LLIST *list, const LELEMENT *element) {
    NODE *prev = NULL;
    NODE *node = list->head;

    while (node != NULL) {
        if (node->element.data == element->data) {
            NODE *tmp = node;
            node = node->next;
            LListRemove(list, prev, tmp);
        } else {
            prev = node;
            node = node->next;
        }
    }
}

// 销毁链表
void LListDestroy(LLIST *list) {
    NODE *node = list->head;

    while (node != NULL) {
        NODE *tmp = node;
        node = node->next;
        free(tmp);
    }

    list->size = 0;
}

// 输入数据元素
void LElementInput(LELEMENT *element) {
    scanf("%f", &(element->data));
}

// 输出链表
void LListOutput(const LLIST *list) {
    NODE *node = list->head;

    while (node != NULL) {
        printf("%.1f", node->element.data);
        if (node->next != NULL) {
            putchar(','); // 输出逗号分隔符
            putchar(' ');
        }
        node = node->next;
    }
}

// 输入链表
void LListInput(LLIST *list) {
    int n;
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        LELEMENT element;
        LElementInput(&element);
        LListAdd(list, &element);
    }
}

int main() {
    LELEMENT x;
    LLIST a;
    LListCreate(&a);
    LListInput(&a);
    LElementInput(&x);
    LListRemoveValue(&a, &x);
    LListOutput(&a);
    putchar('\n');
    LListDestroy(&a);
    return 0;
}

这个程序中，我们通过一个单链表来实现线性表的操作。我们定义了 `LELEMENT` 结构体来存储数据元素，定义了 `NODE` 结构体来存储链表结点，定义了 `LLIST` 结构体来存储链表本身。我们提供了一系列函数来对链表进行操作，包括：

- `LListCreate`：初始化链表。
- `LListAdd`：在链表末尾添加结点。
- `LListRemove`：从链表中删除结点。
- `LListRemoveValue`：删除链表中所有与指定值相同的结点。
- `LListDestroy`：销毁链表。
- `LElementInput`：输入数据元素。
- `LListOutput`：输出链表。
- `LListInput`：输入链表。

在 `main` 函数中，我们首先调用 `LListCreate` 函数初始化链表，然后调用 `LListInput` 函数输入链表，调用 `LElementInput` 函数输入指定值，再调用 `LListRemoveValue` 函数删除链表中所有与指定值相同的结点，最后调用 `LListOutput` 函数输出链表，调用 `LListDestroy` 函数销毁链表。