链表是一种存储结构，在物理存储单元上表现的是非连续、非顺序的一种存储结构。常见的链表有单向链表、双向链表、循环链表等。

单向链表

每个节点之间通过地址的方式进行单向链接，头部指针指向首个节点的内存地址，首节点中存储下一个的地址，以此类推，直至末尾节点后面没有节点时，末尾节点指向NULL。

双向链表

每个节点之间通过地址的方式进行双向链接，头部指针指向首个节点的内存地址，首节点中存储了两个地址，分别是：下一个节点的地址、前一个节点的地址（首节点前面没有则为NULL），以此类推，直至最后一个节点后面没有节点时，最后一个节点存储了倒数第2个节点的地址和空节点NULL。

循环链表

同单向链表类似，每个节点之间通过地址的方式进行单向链接，但末尾的节点不再指向NULL（空节点），而是指向首节点。

单向链表的实现

实现步骤分析：

1. 在.h头文件中定义节点数据结构体；

2. 在.h头文件中分别声明链表的增、删、改、查函数；

1. 声明链表的添加函数；

2. 声明链表的输出函数；

3. 声明链表的删除函数；

4. 声明链表的修改函数；

3. 在.c文件中创建头部指针；

4. 在.c文件中实现.h文件中分别实现的增、删、改、查函数；

1. 实现链表的添加函数；

2. 实现链表的输出函数；

3. 实现链表的删除函数；

4. 实现链表的修改函数；

实现代码如下：

LinkedList.h

#ifndef __LINKED_LIST_H__
#define __LINKED_LIST_H__

// 1. 在`.h`头文件中定义节点数据结构体；
typedef struct LinkedListNode {
    int data;
    struct LinkedListNode* next;
} NODE;

// 2. 在.h头文件中分别声明链表的增、删、改、查函数；

// a. 声明链表的添加函数；
int add_node(int data);	 

// b. 声明链表的输出函数；
void print_all_node();

// c. 声明链表的删除函数；
int delete_node(int data);

// d. 声明链表的修改函数；
int update_node(int old_data, int new_data);

#endif

LinkedList.c

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

// 3. 在.c文件中创建头部指针；
struct LinkedListNode* head;

// 4. 在.c文件中实现.h文件中分别实现的增、删、改、查函数；

// a. 实现链表的添加函数；
int add_node(int data) {
    NODE* p_new_node = (NODE*)malloc(sizeof(NODE));
    p_new_node->data = data;
    p_new_node->next = NULL;

    if (head == NULL) {
        // 当前头部指针为NULL，没有节点，新节点设置为首节点
        head = p_new_node;
    } else {
        NODE* current = head;
        while(current->next != NULL) {
            // 当前节点的下一个节点不为NULL时，让当前节点向后移动一个节点
            current = current->next;
        }
        // 当前节点的下一个节点为NULL，已经到末尾，将新节点添加进去
        current->next = p_new_node;
    }
    return 1;
}

// b. 实现链表的输出函数；
void print_all_node() {
    NODE* current = head;
    while(current != NULL) {
        printf("当前节点地址：%#p, 值为：%d\n", current, current->data);
        current = current->next;
    }
}

// c. 实现链表的删除函数；
int delete_node(int data) {
    if (head == NULL) {
        return 0;
    }

    // 查找节点
    NODE* current = head;
    NODE* previous;
    while(current != NULL && current->data != data) {
        previous = current;
        current = current->next;
    }

    if (previous == NULL) {
        // 第一个节点就找到了
        head = current->next;
        return 1;
    }

    if (current == NULL) {
        // 没找到，删除失败
        return 0;
    }

    // 删除当前节点：前一个节点直接指向当前节点的下一个节点
    previous->next = current->next;
    // 释放当前节点的内存
    free(current);
    return 1;
}

// d. 实现链表的修改函数；
int update_node(int old_data, int new_data) {
    if(head == NULL) {
        return 0;
    }

    NODE* current = head;
    while(current != NULL) {
        if (current->data == old_data) {
            current->data = new_data;
            break;
        }
        current = current->next;
    }
    return 1;
}

main.c

#include <stdio.h>
#include "LinkedList.h"

int main() {

    add_node(1);
    add_node(2);
    add_node(3);
    add_node(4);
    add_node(5);
    print_all_node();

    printf("----------------------------\n");

    delete_node(2);
    print_all_node();
    
    printf("----------------------------\n");

    update_node(3, 10);
    print_all_node();
    return 0;
}