假设一个线性表采用顺序表表示，设计一个算法，删除其中所有值等于x的元素，要求算法时间复杂度为O(n),空间复杂度O(1)通过c语言程序实现

假设我们有一个单链表，我们要删除其中所有值等于给定值 `x` 的节点，同时保持时间复杂度为 O(n)，空间复杂度为 O(1)。以下是 C 语言的解决方案：

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

// 定义链表结构体
typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

// 创建新节点
ListNode* createNode(int val) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (newNode != NULL) {
        newNode->val = val;
        newNode->next = NULL;
    }
    return newNode;
}

// 删除链表中值为 x 的节点
void removeElements(ListNode** head, int x) {
    // 如果头结点需要删除，更新头指针
    if (*head && (*head)->val == x) {
        ListNode* temp = *head;
        *head = (*head)->next;
        free(temp);
    }

    // 遍历链表
    ListNode* current = *head;
    while (current != NULL && current->next != NULL) {
        // 如果下一个节点值等于 x，替换它，然后跳过两个节点继续遍历
        if (current->next->val == x) {
            ListNode* toReplace = current->next;
            current->next = current->next->next;
            free(toReplace);
        } else {
            current = current->next;
        }
    }
}

// 打印链表
void printList(ListNode* head) {
    while (head != NULL) {
        printf("%d -> ", head->val);
        head = head->next;
    }
    printf("NULL\n");
}

int main() {
    // 初始化示例链表
    ListNode* list = createNode(1);
    list->next = createNode(2);
    list->next->next = createNode(x); // 想要删除的值
    list->next->next->next = createNode(3);
    list->next->next->next->next = createNode(4);

    printf("Original List:\n");
    printList(list);

    int deleteValue = 3; // 要删除的值
    removeElements(&list, deleteValue);

    printf("\nList after removing elements with value %d:\n", deleteValue);
    printList(list);

    return 0;
}

这个程序首先创建了一个包含特定值的链表，然后调用 `removeElements` 函数删除所有值为 `x` 的节点。这个函数会遍历整个链表，遇到值为 `x` 的节点时就直接替换并释放内存，以达到 O(n) 的时间复杂度，因为每个节点只访问一次。