【数据结构实战】双向链表：在指定位置插入数据

一、双向链表结构与基础函数

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

// 定义链表存储的数据类型为int
typedef int ElemType;

// 定义双向链表节点结构
typedef struct node {
    ElemType data;       // 数据域：存储节点数据
    struct node *next;   // 后继指针：指向后一个节点
    struct node *prev;   // 前驱指针：指向前一个节点
} Node;

/**
 * 初始化双向链表（带头节点）
 * 返回值：指向头节点的指针
 */
Node* initList() {
    // 动态分配头节点内存
    Node *head = (Node*)malloc(sizeof(Node));
    if (head == NULL) {  // 内存分配失败判断
        printf("内存分配失败！\n");
        exit(1);
    }
    head->data = 0;      // 头节点数据域无实际意义，仅作占位
    head->next = NULL;   // 后继指针初始化为空（链表初始为空）
    head->prev = NULL;   // 前驱指针初始化为空
    return head;
}

/**
 * 获取双向链表的尾节点
 * 参数 L：链表头节点指针
 * 返回值：尾节点指针
 */
Node* get_tail(Node *L) {
    Node *p = L;
    // 遍历链表，直到找到next为NULL的节点（即尾节点）
    while (p->next != NULL) {
        p = p->next;
    }
    return p;
}

/**
 * 双向链表尾插法（在链表末尾插入新节点）
 * 参数 tail：当前尾节点指针
 * 参数 e：待插入的数据
 * 返回值：新的尾节点指针
 */
Node* insertTail(Node *tail, ElemType e) {
    // 1. 为新节点分配内存
    Node *p = (Node*)malloc(sizeof(Node));
    if (p == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }

    // 2. 给新节点赋值
    p->data = e;         // 新节点数据域 = 待插入数据
    p->prev = tail;      // 新节点前驱指针 = 当前尾节点
    tail->next = p;      // 当前尾节点的后继指针 = 新节点
    p->next = NULL;      // 新节点作为新尾节点，后继指针置空

    // 3. 返回新的尾节点指针
    return p;
}

/**
 * 遍历并打印双向链表（从第一个有效节点开始）
 * 参数 L：链表头节点指针
 */
void listNode(Node* L) {
    Node *p = L->next;  // 从第一个有效节点开始遍历（跳过头节点）
    while (p != NULL) { // 遍历到链表末尾（next为NULL时停止）
        printf("%d ", p->data);  // 打印当前节点数据
        p = p->next;             // 指针后移
    }
    printf("\n");  // 遍历结束后换行
}

---

二、指定位置插入核心代码（重点）

/**
 * 双向链表指定位置插入（在第pos个位置后插入新节点，pos从1开始）
 * 参数 L：链表头节点指针
 * 参数 pos：插入位置（1为第一个有效节点的位置）
 * 参数 e：待插入的数据
 * 返回值：1表示插入成功，0表示插入失败
 */
int insertNode(Node *L, int pos, ElemType e) {
    Node *p = L;
    int i = 0;
    // 1. 遍历找到第pos-1个节点（即插入位置的前驱节点）
    while (i < pos - 1) {
        p = p->next;
        i++;
        // 如果遍历到链表末尾仍未找到目标位置，说明pos非法
        if (p == NULL) {
            return 0;
        }
    }

    // 2. 为新节点分配内存
    Node *q = (Node*)malloc(sizeof(Node));
    if (q == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }

    // 3. 给新节点赋值
    q->data = e;         // 新节点数据域 = 待插入数据
    q->prev = p;         // 新节点前驱 = 第pos-1个节点
    q->next = p->next;   // 新节点后继 = 原第pos个节点

    // 4. 如果原第pos个节点存在，修改其前驱指针
    if (p->next != NULL) {
        p->next->prev = q;
    }

    // 5. 修改前驱节点的后继指针，完成插入
    p->next = q;

    return 1;  // 插入成功
}

指定位置插入核心思想：

1. 定位前驱节点 ：先遍历到要插入位置的前一个节点 （pos-1位置），保证新节点能挂接到正确位置。
2. 新节点搭桥 ：
   • 新节点 q 的 prev 指向 p（前驱节点），next 指向 p->next（原后继节点）。
   • 如果原后继节点存在，要让它的 prev 指向新节点 q，保证双向链接完整。
3. 前驱节点挂接 ：最后让 p->next 指向新节点 q，完成 "插入到第 pos 个位置" 的操作。
4. 边界处理 ：必须判断 p->next 是否为 NULL（即插入到链表末尾），避免对空指针解引用。

---

三、完整可运行代码（含主函数测试）

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

typedef int ElemType;

typedef struct node {
    ElemType data;
    struct node *next;
    struct node *prev;
} Node;

// 初始化双向链表
Node* initList() {
    Node *head = (Node*)malloc(sizeof(Node));
    if (head == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }
    head->data = 0;
    head->next = NULL;
    head->prev = NULL;
    return head;
}

// 获取双向链表的尾节点
Node* get_tail(Node *L) {
    Node *p = L;
    while (p->next != NULL) {
        p = p->next;
    }
    return p;
}

// 双向链表尾插法
Node* insertTail(Node *tail, ElemType e) {
    Node *p = (Node*)malloc(sizeof(Node));
    if (p == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }
    p->data = e;
    p->prev = tail;
    tail->next = p;
    p->next = NULL;
    return p;
}

// 遍历双向链表
void listNode(Node* L) {
    Node *p = L->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 双向链表指定位置插入
int insertNode(Node *L, int pos, ElemType e) {
    Node *p = L;
    int i = 0;
    while (i < pos - 1) {
        p = p->next;
        i++;
        if (p == NULL) {
            return 0;
        }
    }
    Node *q = (Node*)malloc(sizeof(Node));
    if (q == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }
    q->data = e;
    q->prev = p;
    q->next = p->next;
    if (p->next != NULL) {
        p->next->prev = q;
    }
    p->next = q;
    return 1;
}

// 主函数：测试双向链表指定位置插入
int main() {
    // 1. 初始化双向链表
    Node *list = initList();

    // 2. 尾插法插入初始数据
    Node *tail = get_tail(list);
    tail = insertTail(tail, 10);
    tail = insertTail(tail, 20);
    tail = insertTail(tail, 30);
    printf("初始链表：");
    listNode(list);  // 输出：10 20 30

    // 3. 在第2个位置插入15
    int res = insertNode(list, 2, 15);
    if (res == 1) {
        printf("插入后链表：");
        listNode(list);  // 输出：10 15 20 30
    } else {
        printf("插入失败，位置非法！\n");
    }

    return 0;
}

---

四、运行结果说明

• 初始尾插得到 10 → 20 → 30。
• 在第 2 个位置插入 15 后，链表变为 10 → 15 → 20 → 30，符合预期。

---

五、尾插法核心思想回顾

1. 定位尾节点：通过 get_tail 遍历找到 链表最后一个节点。
2. 新节点连接：新节点 p 的 prev 指向原尾节点，原尾节点的 next 指向新节点，新节点的 next 置为 NULL。
3. 更新尾节点：函数返回新节点指针，方便后续连续尾插，避免重复遍历找尾。
4. 顺序保证：先建立新节点与原尾节点的双向链接 ，再将新节点的 next 置空，保证链表结构完整。