「链表实战全解析：从动态车厢连接到约瑟夫环杀猴算法」

1. 链表 = 火车车厢？揭秘动态内存布局

小白困惑：链表插入删除为何高效？指针如何避免“断链”？

生活类比：

• 链表 ≈ 火车车厢（每节车厢独立存在，通过挂钩连接）

• 插入车厢：在任意位置插入新车厢，仅需调整前后挂钩（时间复杂度O(1)）

• 头节点 ≈ 火车头（不载客，仅管理车厢连接）

代码对比：
顺序表插入（需移动元素）：

// 类似搬动所有乘客腾出座位
void insert(int arr[], int pos, int data) {
    for (int i = n-1; i >= pos; i--) 
        arr[i+1] = arr[i];
    arr[pos] = data;
}

链表插入（仅调整指针）：

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

void insert(Node* prev, int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    new_node->next = prev->next; // 新车厢挂钩后车
    prev->next = new_node;       // 前车厢挂钩新车厢
}

关键优势：无需整体移动元素，动态扩展灵活！

---

2. 避坑指南：列车长的「三大纪律」

1️⃣ 内存泄漏：丢失车厢钥匙（忘记free）

// 错误！删除节点后未释放内存
void delete(Node* prev) {
    Node* target = prev->next;
    prev->next = target->next; 
    // 忘记 free(target)！
}

2️⃣ 野指针：悬挂的挂钩（未置空指针）

// 正确写法
free(target);
target = NULL; // 防止误操作

3️⃣ 断链风险：错误的挂钩顺序

// 错误！先断开前链接，导致丢失后车厢
prev->next = new_node;
new_node->next = prev->next; // new_node->next 指向自己！

正确顺序：

new_node->next = prev->next; // 先连后车
prev->next = new_node;       // 再连前车

---

3. 链表操作：车厢调度员的「基本功」

场景：实现学生成绩管理系统

尾插法建表（动态添加学生）：

Node* create_list() {
    Node* head = (Node*)malloc(sizeof(Node)); // 火车头
    head->next = NULL;
    Node* tail = head; // 尾指针初始指向头节点

    int score;
    while (scanf("%d", &score), score != -1) {
        Node* new_node = (Node*)malloc(sizeof(Node));
        new_node->data = score;
        new_node->next = NULL;

        tail->next = new_node; // 尾节点挂钩新车厢
        tail = new_node;       // 更新尾指针
    }
    return head;
}

链表反转（车厢反向连接）：

void reverse(Node* head) {
    Node* prev = NULL;
    Node* curr = head->next;
    while (curr != NULL) {
        Node* next = curr->next;
        curr->next = prev;  // 反转挂钩方向
        prev = curr;
        curr = next;
    }
    head->next = prev; // 火车头重新挂钩
}

---

4. 实战升级：约瑟夫环「杀猴算法」

问题：n只猴子围成一圈，从第k只开始报数，数到m的猴子出圈，求最后幸存者

代码实现：

void josephus(int n, int k, int m) {
    // 创建循环链表
    Node* head = (Node*)malloc(sizeof(Node));
    head->data = 1;
    head->next = head;
    Node* tail = head;
    for (int i = 2; i <= n; i++) {
        Node* new_node = (Node*)malloc(sizeof(Node));
        new_node->data = i;
        new_node->next = head;
        tail->next = new_node;
        tail = new_node;
    }

    // 移动到起始位置
    Node* p = head;
    for (int i = 1; i < k; i++) p = p->next;

    // 开始杀猴
    while (p->next != p) {
        // 移动m-1步
        for (int i = 1; i < m-1; i++) p = p->next;
        Node* victim = p->next;
        p->next = victim->next;
        printf("出局：%d\n", victim->data);
        free(victim);
        p = p->next;
    }
    printf("猴王：%d\n", p->data);
}

---

终极挑战：用链表实现「航班管理系统」

要求：

1. 支持航班信息的动态添加、删除、查询

2. 按航班号排序（提示：插入排序）

3. 分文件编写，Makefile管理

代码骨架：

// flight.h
typedef struct {
    char number[10]; // 航班号
    int departure;   // 起飞时间（分钟）
} Flight;

typedef struct Node {
    Flight data;
    struct Node* next;
} FlightNode;

// 实现插入、删除、排序等功能...

链表是C语言动态数据结构的核心：

• 优势：插入/删除高效（O(1)），内存按需分配

• 劣势：随机访问慢（O(n)），需额外指针空间