**双向链表** | 每个结点包含两个指针：`front`（前驱）和 `next`（后继），支持前后双向遍历

1. 单链表的删除运算（函数 Delete_List 实现）：

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

// 定义单链表结点结构
typedef struct Node {
    int data;
    struct Node* next;
} ListNode;

// 删除带表头结点的单链表中第k个元素
int Delete_List(ListNode* L, int k) {
    if (k < 1 || L == NULL) return 0; // 参数非法或空表头

    ListNode* p = L;
    // 找到第k-1个结点（即第k个元素的前驱）
    for (int i = 1; i < k; i++) {
        if (p == NULL) break;
        p = p->next;
    }

    // 若第k-1个结点不存在，或其后无第k个结点
    if (p == NULL || p->next == NULL) {
        return 0; // 删除失败
    }

    ListNode* toDelete = p->next;     // 第k个结点
    p->next = toDelete->next;         // 跳过第k个结点
    free(toDelete);                   // 释放内存

    return 1; // 删除成功
}

说明：

• L 是指向头结点的指针（头结点不存储数据，仅作为链表起始标志）。
• 第1个实际元素是 L->next。
• 时间复杂度：O(k)，需遍历找到前驱结点。
• 空间复杂度：O(1)。

2. 链表的特点：

• 非随机访问：必须从头开始逐个遍历，无法像数组一样通过下标直接访问。
• 动态大小：内存按需分配，适合数据量变化大的场景。
• 插入/删除高效：只要找到位置，修改指针即可，无需移动其他元素（对比数组需整体移动）。
• 额外空间开销：每个结点需额外存储指针域。
• 缓存局部性差：结点在内存中不连续，影响CPU缓存命中率。

3. 其他链表结构：

链表类型	结构特点
双向链表	每个结点包含两个指针：front（前驱）和 next（后继），支持前后双向遍历。删除和插入更灵活，但占用更多空间。
循环链表	尾结点的 next 指向头结点（或首结点），形成环状结构。可用于实现循环队列、约瑟夫问题等。
静态链表	使用数组模拟链表结构，数组下标代替指针。每个元素包含数据域和“游标”（指示下一个元素下标）。适用于不支持动态内存分配的环境。
在单链表中实现第k个位置插入新元素的操作，需要考虑以下逻辑：

• 若 k == 1，表示在第一个位置插入，则将新结点的 next 指向原第一个结点，并更新头结点的指针。
• 否则，找到第 k-1 个结点（前驱结点）p。
• 若 p 不存在或其后无结点（即当前长度不足 k-1），则插入失败。
• 创建新结点，将其插入到 p 之后。

实现代码（C语言）

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

// 定义单链表结点结构
typedef struct Node {
    int data;
    struct Node* next;
} ListNode;

// 在带头结点的单链表L中第k个位置插入新元素x
int Insert_List(ListNode* L, int k, int x) {
    if (k < 1 || L == NULL) return 0; // 参数非法

    ListNode* p = L;
    // 找到第k-1个结点
    for (int i = 1; i < k; i++) {
        if (p == NULL) break;
        p = p->next;
    }

    // 若前驱结点p不存在，则无法插入
    if (p == NULL) {
        return 0; // 插入失败
    }

    // 创建新结点
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (newNode == NULL) return 0; // 内存分配失败

    newNode->data = x;
    newNode->next = p->next;  // 新结点指向原第k个结点
    p->next = newNode;        // 前驱结点指向新结点

    return 1; // 插入成功
}

使用示例

int main() {
    // 创建头结点
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->next = NULL;

    // 插入操作
    Insert_List(head, 1, 10); // 插入第1个位置：10
    Insert_List(head, 2, 20); // 插入第2个位置：20
    Insert_List(head, 2, 15); // 在第2个位置插入15 → [10,15,20]

    // 遍历输出
    ListNode* p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    // 输出：10 15 20

    return 0;
}

复杂度分析：

• 时间复杂度：O(k)，需遍历找到第 k-1 个结点。
• 空间复杂度：O(1)，仅创建一个新结点。

注意事项：

• 必须检查 k 的合法性（不能小于1）。
• 若链表长度不足 k-1，插入失败。
• 动态内存分配需判断是否成功（malloc 是否返回 NULL）。
• 头结点不存储有效数据，仅作为结构统一处理的辅助。
•