双向带头循环链表（进来抄作业）

1.双向循环带头链表的介绍。

所谓双向循环带头链表可以分为以下3类来进行理解：

首先是双向：双向表示后一个节点可以找到自己的前驱节点，这一点和单链表有本质的区别。

其次是带头：若链表带头的话说明，链表有一个头结点，这个头结点也可称为哨兵位的头结点，该节点和普通节点一样，依然有自己的前驱和后继节点，但是头结点的data/val一般为随机值。

最后是循环：循环链表指的是链表的尾结点的后继节点是头结点，头结点的前驱节点是尾结点。构成了一个大大的环状结构。

2.具体代码

List.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
    LTDataType  data;
    struct ListNode*  next;
    struct ListNode*  prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
//创造一个新的节点
ListNode* BuyListNode();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

List.c

#include"List.h"

ListNode* BuyListNode(int x)
{
    ListNode* new = (ListNode*)malloc(sizeof(ListNode));
    new->data = x;
    new->next = NULL;
    new->prev = NULL;
    return new;
}
// 创建返回链表的头结点.
ListNode* ListCreate(void)
{
    ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
    newhead->next = newhead;
    newhead->prev = newhead;
    return newhead;
}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{
    assert(pHead);
    ListNode* cur = pHead;
    while (cur)
    {
        ListNode* next = cur->next;
        free(cur);
        cur = next;
    }
}
// 双向链表打印
void ListPrint(ListNode* pHead)
{
    assert(pHead);
    ListNode* cur = pHead->next;
    while (cur != pHead)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
    assert(pHead);
    ListNode* tail = pHead->prev;
    ListNode* new = BuyListNode(x);
    new->next = tail->next;
    tail->next->prev = new;
    new->prev = tail;
    tail->next = new;
}
// 双向链表尾删
//需要注意此处如果链表初始化后不断删除会使得pHead指针指向的地方不确定,如果后续用户未重新创造双向链表的哨兵位而继续插入数据，会导致非法访问。
//或者加个条件判断判断是否只有一个哨兵位，是的话就不再进行删除。
void ListPopBack(ListNode* pHead)
{
    assert(pHead);
    ListNode* tail = pHead->prev;
    tail->prev->next= tail->next;//左边修改的是指针域，右边是具体的链表的位置。
    tail->next->prev = tail->prev;
    free(tail);
    //tail = NULL;
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
    ListInsert(pHead->next, x);
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
    assert(pHead);
    ListNode* cur = pHead->next;
    if (cur != pHead)
    {
        pHead->next = cur->next;
        cur->next->prev = pHead;
        free(cur);
    }
    cur = NULL;
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x) {
    assert(pHead);
    ListNode* cur = pHead->next;
    while (cur != pHead)
    {
        if (cur->data == x)
        {
            return cur;
        }
        cur = cur->next;
    }
    if (cur == pHead)
    {
        return NULL;
    }
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x) {
    assert(pos);
    ListNode *new=BuyListNode(x);
    ListNode* prev = pos->prev;
    new->next = pos;
    pos->prev = new;
    new->prev = prev;
    prev->next = new;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos) {
    ListNode* prev = pos->prev;
    prev->next = pos->next;
    pos->next->prev = prev;
    free(pos);
}

着重注意这段

// 双向链表尾删

//需要注意此处如果链表初始化后不断删除会使得pHead指针指向的地方不确定,如果后续用户未重新创造双向链表的哨兵位而继续插入数据，会导致非法访问。

//或者加个条件判断判断是否只有一个哨兵位，是的话就不再进行删除。

void ListPopBack(ListNode* pHead)

{

assert(pHead);

ListNode* tail = pHead->prev;

tail->prev->next= tail->next;//左边修改的是指针域，右边是具体的链表的位置。

tail->next->prev = tail->prev;

free(tail);

//tail = NULL;

}

test.c

#include"List.h"
void test(void)
{
    ListNode* phead = ListCreate();
    ListPushBack(phead, 1);
    ListPushBack(phead, 2);
    ListPushBack(phead, 3);
    ListPushBack(phead, 4);
    ListPushBack(phead, 5);
    ListPrint(phead);
    //ListPopBack(phead);
    //ListPopBack(phead);
    //ListPopBack(phead);
    //ListPopBack(phead);
    //ListPrint(phead);
    ListNode* ret = ListFind(phead, 4);
    ListInsert(ret, 1);
    ListInsert(ret, 2);
    ListInsert(ret, 3);   
    ListPrint(phead);
    ListPushFront(phead, -1);
    ListPushFront(phead, -2);
    ListPushFront(phead, -3);
    ListPushFront(phead, -4);
    ListPrint(phead);
    ListPopFront(phead);
    ListPopFront(phead);
    ListPopFront(phead);
    ListPrint(phead);
    ListErase(ret);
    ListPrint(phead);
}
int main()
{
    test();
}

3.总结

事实上通过上面的代码我们不难发现双向循环链表只是看起来结构复杂，但其实思想简单，而且访问的效率非常高。