雙向鏈表節點刪除與插入：C語言標準操作代碼模板

節點定義

typedef struct Node {
    int value;
    struct Node *next;
    struct Node *prev;
} Node;

操作一：刪除 value=91 的節點

// 假設 head 為頭節點指針，且鏈表非空
void delete_value(Node **head, int target) {
    Node *cur = *head;
    while (cur) {
        if (cur->value == target) {
            // 1. 斷開鏈接
            if (cur->prev) cur->prev->next = cur->next;
            else *head = cur->next;  // 刪除頭節點

            if (cur->next) cur->next->prev = cur->prev;
            // 2. 釋放內存
            free(cur);
            return;  // 假設值唯一，刪一個即返回
        }
        cur = cur->next;
    }
}

操作二：在 value=66 和 23 之間插入 value=68 的新節點

void insert_between(Node *head, int after_val, int before_val, int new_val) {
    Node *cur = head;
    while (cur && cur->next) {
        if (cur->value == after_val && cur->next->value == before_val) {
            Node *new_node = malloc(sizeof(Node));
            if (!new_node) return;  // 分配失敗

            new_node->value = new_val;
            // 1. 新節點鏈接後繼
            new_node->next = cur->next;
            new_node->prev = cur;
            // 2. 後繼節點回鏈
            cur->next->prev = new_node;
            // 3. 前驅節點前鏈
            cur->next = new_node;
            return;
        }
        cur = cur->next;
    }
    // 未找到相鄰對，可選：釋放 new_node 或報錯
}

調用示例

int main() {
    // 假設已建立鏈表：... 66 <-> 91 <-> 23 ...
    Node *head = build_list();  // 省略構建代碼

    delete_value(&head, 91);           // 刪除 91
    insert_between(head, 66, 23, 68);  // 66 和 23 間插 68

    // 遍歷驗證
    for (Node *p = head; p; p = p->next)
        printf("%d ", p->value);

    // 釋放整表
    while (head) {
        Node *tmp = head;
        head = head->next;
        free(tmp);
    }
    return 0;
}

關鍵點速記卡

圖解：插入 68 到 66 和 23 之間

插入前：      [66] <-> [23]
                ↓          ↓
            prev=66    prev=23
            next=23    next=66

插入後：      [66] <-> [68] <-> [23]
                ↓        ↓        ↓
            prev=66  prev=66  prev=68
            next=68  next=23  next=68

進階：帶哨兵節點簡化邊界

引入虛擬頭尾節點 head->prev = tail; tail->next = head，形成循環雙向鏈表，刪除/插入無需判斷頭尾，代碼更簡潔健壯，Linux 內核 list_head 即採用此設計。