循环双链表：从原理到C语言实现详解

关注

原创 2025-04-21 10:41:55 495 阅读 AI 写同款· GEO 优化 ›

数据结构----带头循环双链表（带哨兵位）（C语言） 双链表作为数据结构中的非线性表结构，对比于单链表具有它的优势：可以直接找到当前结点的上下结点。但由于双链表的这个特性，如果不带哨兵位，一不小心就可能手撕一个错的双链表出来。所以今天我们写一个带哨兵位的循环双链表。非循环双链表的话，实现起来和循环双链表差别不大，只是头尾并没有相连，而是指向NULL。今天，我将手撕一个双链表，包括双链表的初始化，插入删除，查找等一系列操作，准备好了吗！！！先来一个抽象图，理解理解。来了！阅读详情

一、循环双链表的特性与优势

1.1 核心特性

环形结构：头节点的prior指向尾节点，尾节点的next指向头节点
双向遍历：支持前向（prior）和后向（next）两种遍历方式
空表状态：当链表为空时，头节点自成环（next和prior都指向自己）

1.2 性能优势

高效头尾操作：时间复杂度保持O(1)
空间利用率：相比数组实现无需预分配内存
应用场景：浏览器历史记录、音乐播放列表、undo/redo操作等需要双向访问的场景

二、核心数据结构实现

2.1 节点结构定义

typedef struct DNode {
    int data;          // 数据域
    struct DNode *prior; // 前驱指针
    struct DNode *next;  // 后继指针
} DNode, *DLinkList;

2.2 初始化操作

bool Init_DLinkList(DLinkList &L) {
    L = (DNode*)malloc(sizeof(DNode));
    if(L == NULL) return false;
    L->next = L;    // 关键点1：形成环形结构
    L->prior = L;   // 关键点2：双向闭环
    return true;
}

三、关键操作实现解析

3.1 插入操作（时间复杂度O(n)）

bool DlinkList_Insert(DLinkList &L, int i, int e) {
    // 参数校验省略...
    
    // 定位到插入位置前驱
    DNode *p = L;
    int j = 0;
    while(p->next != L && j < i-1) {  // 关键点1：遍历终止条件
        p = p->next;
        j++;
    }
    
    // 创建新节点
    DNode *s = (DNode*)malloc(sizeof(DNode));
    s->data = e;
    
    // 四步指针调整
    s->next = p->next;    // ①
    s->prior = p;         // ②
    p->next->prior = s;   // ③
    p->next = s;          // ④
    return true;
}

指针调整示意图：

插入前：A <-> B
插入X到A之后：

步骤①：X.next = A.next (B)
步骤②：X.prior = A
步骤③：B.prior = X
步骤④：A.next = X

最终：A <-> X <-> B

3.2 删除操作（时间复杂度O(n)）

bool DlinkList_Delete(DLinkList &L, int i) {
    // 参数校验省略...
    
    // 定位目标节点
    DNode *p = L->next;
    int j = 1;
    while(p != L && j < i) {  // 关键点1：环形遍历
        p = p->next;
        j++;
    }
    
    // 调整相邻节点指针
    p->prior->next = p->next;  // ①
    p->next->prior = p->prior; // ②
    free(p);
    return true;
}

删除过程示意图：

删除节点B：
A <-> B <-> C

步骤①：A.next = C
步骤②：C.prior = A

最终：A <-> C

四、边界条件处理

4.1 特殊位置插入

插入位置	处理方式
头插法	插入到头节点之后
尾插法	插入到尾节点之前（自动闭环）

4.2 删除特殊情况

// 删除唯一数据节点的情况处理
if(p->next == p) {  
    p->prior->next = L;
    L->prior = p->prior;
}

五、内存管理与调试

5.1 内存销毁实现

void DestroyList(DLinkList &L) {
    DNode *p = L->next, *q;
    while(p != L) {  // 关键点：环形遍历条件
        q = p;
        p = p->next;
        free(q);
    }
    free(L);  // 释放头节点
    L = NULL; // 避免悬空指针
}

5.2 调试技巧

可视化打印函数：

void PrintList(DLinkList L) {
    DNode *p = L->next;
    printf("Head <-> ");
    while(p != L) {
        printf("%d <-> ", p->data);
        p = p->next;
    }
    printf("Head\n");
}

内存检测工具

# 使用Valgrind检测内存泄漏
valgrind --leak-check=full ./program

六、性能优化建议

6.1 时间复杂度优化

操作	原始复杂度	优化方案
头插	O(1)	直接操作头节点
尾插	O(n)	维护尾指针（O(1)）

6.2 添加尾指针优化

typedef struct {
    DLinkList head;
    DLinkList tail;  // 新增尾指针
} EnhancedList;

// 尾插法优化实现
void TailInsert(EnhancedList &list, int e) {
    DNode *s = CreateNode(e);
    s->prior = list.tail;
    s->next = list.head;
    list.tail->next = s;
    list.head->prior = s;
    list.tail = s;
}

七、测试用例验证

7.1 正常流程测试

// 测试代码
DLinkList L;
Init_DLinkList(L);

// 验证插入顺序
DlinkList_Insert(L, 1, 10);  // Head <-> 10 <-> Head
DlinkList_Insert(L, 2, 20);  // Head <-> 10 <-> 20 <-> Head
DlinkList_Insert(L, 1, 5);   // Head <-> 5 <-> 10 <-> 20 <-> Head

// 验证删除操作
DlinkList_Delete(L, 2);      // 删除10 → Head <-> 5 <-> 20 <-> Head
DlinkList_Delete(L, 1);      // 删除5 → Head <-> 20 <-> Head

7.2 边界测试

// 测试空表删除
DlinkList_Delete(L, 1);  // 应返回false

// 测试超长插入
DlinkList_Insert(L, 100, 1);  // 应返回false

八、扩展应用场景

8.1 浏览器历史记录

// 前进后退功能实现框架
typedef struct {
    DLinkList history;
    DNode *current;
} Browser;

void GoForward(Browser *b) {
    if(b->current->next != b->history)
        b->current = b->current->next;
}

void GoBack(Browser *b) {
    if(b->current->prior != b->history)
        b->current = b->current->prior;
}

8.2 音乐播放器实现

// 循环播放功能示例
DNode* NextSong(DNode *current) {
    return current->next == L ? L->next : current->next;
}

DNode* PrevSong(DNode *current) {
    return current->prior == L ? L->prior : current->prior;
}

九、常见问题排查

9.1 内存泄漏检测

症状	排查方法
程序退出后内存未释放	使用DestroyList逐节点释放
野指针访问	释放后置指针为NULL

9.2 环形结构验证

// 验证链表完整性
bool VerifyCycle(DLinkList L) {
    if(L == NULL) return false;
    
    DNode *slow = L->next;
    DNode *fast = L->next;
    
    while(fast != L && fast->next != L) {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast) return true;
    }
    return false;
}