在C语言中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表的基本操作包括创建、插入、删除和遍历等。

下面是一个简单的链表节点结构体定义：

  1. struct Node {
  2. int data;
  3. struct Node* next;
  4. };

其中，data表示节点中的数据元素，next是指向下一个节点的指针。

  1. 创建链表：

链表的创建通常是通过定义一个指向链表头节点的指针，然后逐个添加节点来实现的。例如：

  1. struct Node* head = NULL; // 定义指向链表头节点的指针，初始化为空
  2. struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); // 创建新节点
  3. new_node->data = 1; // 设置节点中的数据元素
  4. new_node->next = NULL; // 设置节点的指针为空
  5. head = new_node; // 将头指针指向新节点
  1. 插入节点：

链表的插入操作通常是在链表的末尾或指定位置插入新节点。在链表末尾插入节点的操作比较简单，只需要将新节点的指针指向原链表的最后一个节点的指针即可。例如：

  1. struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); // 创建新节点
  2. new_node->data = 2; // 设置节点中的数据元素
  3. new_node->next = NULL; // 设置节点的指针为空
  4. if (head == NULL) { // 如果链表为空，将新节点设置为头节点
  5. head = new_node;
  6. } else { // 否则，将新节点插入到链表末尾
  7. struct Node* last = head;
  8. while (last->next != NULL) { // 遍历找到链表的最后一个节点
  9. last = last->next;
  10. }
  11. last->next = new_node; // 将最后一个节点的指针指向新节点
  12. }

要在指定位置插入节点，需要先找到插入位置的前一个节点，然后将前一个节点的指针指向新节点，新节点的指针指向下一个节点。例如：

  1. struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); // 创建新节点
  2. new_node->data = 3; // 设置节点中的数据元素
  3. new_node->next = NULL; // 设置节点的指针为空
  4. struct Node* prev = head; // 定义指向插入位置前一个节点的指针
  5. struct Node* curr = head->next; // 定义指向插入位置的指针，初始化为头节点的下一个节点
  6. while (curr != NULL && curr->data < 20) { // 遍历找到插入位置的前一个节点和插入位置的节点
  7. prev = curr;
  8. curr = curr->next;
  9. }
  10. prev->next = new_node; // 将前一个节点的指针指向新节点
  11. new_node->next = curr; // 将新节点的指针指向插入位置的节点（如果存在）
  1. 删除节点：

删除节点需要找到需要删除的节点，然后将前一个节点的指针指向下一个节点。例如：

  1. struct Node* delete_node = head; // 定义指向要删除节点的指针，初始化为头节点
  2. struct Node* prev = NULL; // 定义指向要删除节点前一个节点的指针
  3. struct Node* curr = head; // 定义指向要删除节点后一个节点的指针
  4. while (curr != NULL && curr != delete_node) { // 遍历找到要删除的节点和它前后的节点
  5. prev = curr;
  6. curr = curr->next;
  7. }
  8. if (prev == NULL) { // 如果要删除的是头节点
  9. head = delete_node->next; // 将头指针指向要删除节点的下一个节点
  10. } else { // 如果要删除的是中间节点或尾节点
  11. prev->next = delete_node->next; // 将前一个节点的指针指向要删除节点的下一个节点
  12. }
  13. free(delete_node); // 释放要删除的节点的内存空间
  1. 遍历链表：

遍历链表通常是通过定义一个指针指向链表头节点，然后循环遍历每个节点的数据元素。例如：

  1. struct Node* curr = head; // 定义指向当前节点的指针，初始化为头节点
  2. while (curr != NULL) { // 循环遍历每个节点
  3. printf(“%d “, curr->data); // 输出当前节点的数据元素
  4. curr = curr->next; // 将当前节点的指针指向下一个节点
  5. }

以上是链表的基本操作，链表的其他操作还包括反转链表、查找元素等。

  1. 反转链表：

反转链表需要定义一个指针指向当前节点，另一个指针指向下一个节点，然后将两个指针交换位置，直到两个指针相遇为止。例如：

  1. struct Node* reverse_list(struct Node* head) {
  2. struct Node* prev = NULL; // 定义指向当前节点前一个节点的指针
  3. struct Node* curr = head; // 定义指向当前节点的指针，初始化为头节点
  4. struct Node* next = NULL; // 定义指向当前节点后一个节点的指针
  5. while (curr != NULL) { // 遍历链表
  6. next = curr->next; // 将当前节点的指针指向下一个节点
  7. curr->next = prev; // 将当前节点的指针指向前一个节点
  8. prev = curr; // 将当前节点的前一个节点指针指向当前节点
  9. curr = next; // 将当前节点的指针指向下一个节点
  10. }
  11. return prev; // 返回反转后的链表头节点指针
  12. }
  1. 查找元素：

查找元素需要遍历链表，直到找到目标元素或遍历到链表末尾为止。例如：

  1. int search(struct Node* head, int target) {
  2. struct Node* curr = head; // 定义指向当前节点的指针，初始化为头节点
  3. while (curr != NULL) { // 遍历链表
  4. if (curr->data == target) { // 如果当前节点的数据元素等于目标元素
  5. return 1; // 返回1表示找到目标元素
  6. }
  7. curr = curr->next; // 将当前节点的指针指向下一个节点
  8. }
  9. return 0; // 返回0表示未找到目标元素
  10. }