带头节点的双向循环链表的基本操作

双向循环链表：

双向循环链表中每一个节点都有一个直接的前驱和一个直接的后继

双向循环链表中的节点有两个指针域和一个存放数据的地方，两个指针域一个存放下一个节点的地址，一个存放前一个指针的地址

下面是双向循环链表的基本操作：
CircularList.h
#ifndef _LINKLIST_H_
#define _LINKLIST_H_
 
#include<stdlib.h>
#include<assert.h>
 
typedef int DataType;
 
typedef struct DListNode
{
    DataType data;
    struct DListNode *next;
    struct DListNode *previous;
}DListNode;
 
DListNode *BuyListNode(DataType data);
void DListInit(DListNode **pHead);
void DListPushBack(DListNode *pHead,DataType data);
void DListPopBack(DListNode *pHead);
void DListPushFront(DListNode *pHead, DataType data);
void DListPopFront(DListNode *pHead);
void DListInsert(DListNode *pos,DataType data);
void DListErase(DListNode *pos);
DListNode *DListFind(DListNode *pHead, DataType data);
void DListDestroy(DListNode *pHead);
 
 
#endif //_LINKLIST_H_
建立一个节点：
首先动态分配一块节点空间，然后给函数传入一个数据，并且将该数据放到节点的数据块中，将节点的左右指针域赋为空

#include"CircularList.h"
 
//创建一个节点
DListNode *BuyListNode(DataType data)
{
    DListNode *ret = (DListNode *)malloc(sizeof(DListNode));//动态分配一块节点大小的空间
    if(NULL == ret)
    {
        assert(0);
    }
    else
    {
        ret->data = data; //给节点中的数据块赋值
        ret->next = NULL;//给节点的前后指针域赋值
        ret->previous = NULL;
    }
    return ret;//返回节点的地址
}
双向链表的尾插：
1.首先判断是不是空链表，如果是空链表的话，将它的previous指针域指向头节点，然后将它next指针域也指向头节点，将头节点的previous指针域指向新节点，将它的next指针域指向新节点

2.如果链表不为空的话，直接将最后一个元素（头节点的previous域存放的是最后一个节点的地址）next域指向新节点（pHead->previous->next = 新节点的地址）将新节点的previous指针域指向最后一个节点（新节点->previous = pHead->previous）,然后将头节点的previous域指向新节点，将新节点的next域指向头节点，这样就插入完成了。

//双向链表的尾插
void DListPushBack(DListNode *pHead,DataType data)
{
    DListNode *cur = NULL;
    //如果链表内只有头节点
    if(pHead->next == pHead)
    {
        cur = BuyListNode(data);
        pHead->next = cur;
        cur->previous = pHead;
        cur->next = pHead;
        pHead->previous = cur;
    }
    //如果链表内有其他节点
    else
    {
        cur = BuyListNode(data);
        pHead->previous->next  = cur;
        cur->previous = pHead->previous;
        pHead->previous = cur;
        cur->next = pHead;
    }
}
尾删法
如果链表为空的话，直接返回，

如果链表不为空的话，将头节点的prev域指向最后一个元素的prev（也就是倒数第2个节点），然后将倒数第二个元素的next指向头节点

//双向链表的尾删
void DListPopBack(DListNode *pHead)
{
    DListNode *cur = NULL;//用来表示要删除的节点
    //如果链表内只有头节点，不用删除，直接返回
    if(pHead == pHead->next)
        return;
    else
    {
        cur = pHead->previous;//记录要删除的节点
        pHead->previous = cur->previous;//将头节点的prev域指向倒数最后一个节点
        cur->previous->next = pHead;//将删除节点的前一个节点的prev域指向头节点
        free(cur);
        cur = NULL;
    }
}
头插法：
当链表为空时，将头节点的next域和prev指向新节点，然后将新节点的next域和prev域指向头节点

当链表不为空时，首先将新节点的next域指向头节点的next域，然后将原来头节点后面的节点的prev域指向新节点，然后将头节点的next域指向新节点，然后再将新节点的prev域指向头节点

//头插
void DListPushFront(DListNode *pHead, DataType data)
{
    DListNode *cur = BuyListNode(data);
    //当链表只有头节点时
    if(pHead->next == pHead)
    {
        pHead->next = cur;
        cur->next = pHead;
        cur->previous = pHead;
        pHead->previous = cur;
    }
    else
    {
        cur->next = pHead->next;//将新节点的next域指向原链表中头节点后面的节点
        pHead->next ->previous = cur;//然后将原头节点中后面节点prev域指向新节点
        cur->previous = pHead;//将新节点prev域指向头节点
                pHead->next = cur;//将头节点的next域指向新节点     
    }
}
头删法：
如果链表为空的话，不需要删除节点

如果链表为空的话，首先将要删除节点后面第一个节点的prev域指向头节点，将头节点的next域指向要删除节点后面第一个节点

//双向链表的头删
void DListPopFront(DListNode *pHead)
{
    DListNode *cur = pHead->next;
    if(pHead->next == pHead)//如果链表为空，直接返回
        return;
    else
    {
                pHead->next = cur->next;//将头节点的next域指向要删除节点下面的一个节点
        cur->next->previous = pHead;//将要删除节点的下一个节点的prev域指向头节点
        free(cur);
        cur = NULL;
    }
}
在指定位置插入一个节点：
只给你插入的位置(pos)，要你在指定的位置(pos)之后插入一个节点

因为是双向循环链表，所以给你一个节点的位置，你就知道了该位置前面一个节点的位置和后面一个节点的位置。

然后将先将你要插入节点的prev域指向和pos。.然后将新节点的next域指向pos中next域中存放的地址。之后pos的next域指向新节点，然后新节点后面的prev域指向新节点。

//在任意位置插入
void DListInsert(DListNode *pos,DataType data)
{
    DListNode *cur = BuyListNode(data);
    if(NULL == pos)
        return;
    //在指定位置之后插入一个节点
    else
    {
        cur->next = pos->next;
        cur->previous = pos;
        pos->next = cur;
        cur->next->previous = cur;
    }
}
在指定位置删除一个节点
如果指定位置（pos）为空的话，直接返回。

如果二者都不为空的话，直接将pos前面节点的next域指向pos后面的节点，然后将pos后面节点的prev域指向pos前面的节点。

void DListErase(DListNode *pos)
{
    if(pos == NULL)//如果指定位置为空的话
        return ;
    else
    {
        pos->previous->next = pos->next;//将指定位置前面节点的next域指向pos后面的节点
        pos->next->previous = pos->previous;//将指定位置后面节点的prev域指向pos前面的节点
        free(pos);
        pos = NULL;
    }
}
其他的基本操作：
//查找Data数据的节点
DListNode *DListFind(DListNode *pHead, DataType data)
{
    DListNode *cur = pHead->next;//用来记录头节点的位置
    while(cur != pHead)
    {
        if(cur->data == data)
            return cur;
        cur = cur->next;
    }
    return NULL;
}
//销毁双向循环链表
void DListDestroy(DListNode *pHead)
{
    DListNode *cur = pHead->next;
    while(cur != pHead)
    {
        DListNode *ret = cur;
        cur = cur->next;
        free(ret);
        ret = NULL;
    }
    free(pHead);
    pHead = NULL;
}
main.c
#include"CircularList.h"
 
void Text()
{
    DListNode *pHead = NULL;
    DListInit(&pHead);
    DListPushBack(pHead, 1);
    DListPushBack(pHead, 2);
    DListPushBack(pHead, 3);
    DListPushFront(pHead, 4);
    DListPushFront(pHead, 5);
    DListPopFront(pHead);
    DListInsert(DListFind(pHead, 3),6);
    DListErase(DListFind(pHead,4));
    DListDestroy(pHead);
}
 
int main()
{
    Text();
    return 0;
}
 
--------------------- 
作者：Ksaila 
来源：CSDN 
原文：https://blog.csdn.net/ksaila/article/details/82227682 
版权声明：本文为博主原创文章，转载请附上博文链接！