用c语言实现顺序存储结构和链式存储结构两种结构下线性链表的基本操作（创建、添加、删除、遍历输出和原地逆转）。

在C语言中，我们通常会分别使用顺序存储（数组）和链接存储（链表）来实现线性链表。

**顺序存储（数组实现）：**

1. **创建（初始化）：**
使用动态内存分配（如`malloc`）为链表分配一段连续的空间，并用`NULL`作为结束标记。

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* create_array_list(int capacity) {
    Node* list = (Node*)malloc(capacity * sizeof(Node));
    list[capacity - 1].next = NULL; // 设置终止节点
    return list;
}

2. **添加（插入）：**
根据指定位置插入元素，若超过数组长度，则需考虑扩容。

void insert_array(Node** head, int index, int value) {
    if (index < 0 || index >= (*head)->size) {
        printf("Index out of range.\n");
        return;
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = (*head)[index];
    (*head)[index] = newNode;
}

3. **删除：**
删除指定索引处的元素，如果该位置不是空指针。

void delete_array(Node** head, int index) {
    if (index < 0 || index >= (*head)->size || !(*head)[index]) {
        printf("Invalid deletion position.\n");
        return;
    }
    Node* temp = *head;
    for (int i = 0; i < index; ++i) {
        temp = temp->next;
    }
    free(temp->next);
    temp->next = (*head)->next;
    (*head) = temp;
}

4. **遍历输出：**
从头到尾访问每个元素。

void print_array(Node* head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

5. **原地逆转：**
可通过两个指针分别指向当前节点和前一个节点来进行逆转。

void reverse_array(Node** head) {
    Node* prev = NULL;
    Node* current = *head;
    Node* nextTemp;
    while (current != NULL) {
        nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }
    *head = prev;
}

**链式存储（链表实现）：**

类似的操作，在链表上进行，不需要预先设定固定大小：

1. 创建链表：

   Node* create_linked_list() {
       Node* head = (Node*)malloc(sizeof(Node));
       head->data = 0;
       head->next = NULL;
       return head;
   }

2. 添加（插入）：

   void insert_linked_list(Node** head, int value) {
       Node* newNode = (Node*)malloc(sizeof(Node));
       newNode->data = value;
       newNode->next = *head;
       *head = newNode;
   }

3. 删除：

   void delete_linked_list(Node** head, int value) {
       Node* temp = *head;
       while (temp != NULL && temp->data != value) {
           temp = temp->next;
       }
       if (temp == NULL) return;
       Node* next = temp->next;
       free(temp);
       *head = next;
   }

其他操作如遍历、逆转等也适用于链表，只需替换节点间的指针操作即可。