带头双向循环链表

回顾我们之前学过的单链表，带头双向循环链表就是在pphead（头节点）上添加一个有一个指针，指向最后一个节点，最后一个节点的next指针指向头节点。

单链表的表示方法：

 循环连链表表示方法：

带头循环双向链表表示方法：

 

 头文件：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

ListNode* LTInit();
// 创建返回链表的头结点.
ListNode* BuyLTNode(LTDataType x);
// 双向链表打印
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);

结构体的初始化：

ListNode* LTInit()
{
	ListNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
}

新建一个结构体：

ListNode* BuyLTNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
}

双向链表打印：

void ListPrint(ListNode* pHead)
{
    assert(pHead); 
    ListNode* cur = pHead->next;
    while (cur != pHead)
    {
        printf("%d", cur->data);
        cur = cur->next;
        printf("->");

    }
}

双向链表尾插：
 

void ListPushBack(ListNode* pHead, LTDataType x)
{
    assert(pHead);
    ListNode* tail = pHead->prev;
    ListNode* newnode = BuyLTNode(x);
    tail->next = newnode;
    newnode->next = pHead;
    pHead->prev = newnode;
}

 双向链表头插：

void ListPushFront(ListNode* pHead, LTDataType x)
{
    assert(pHead);
    ListNode* newnode = BuyLTNode(x); 
    /*ListNode* first = pHead->data;
    pHead->next = newnode;
    newnode->prev = pHead;
    newnode->next = first;
    first->prev = pHead;*/
    newnode->next = pHead->next;
    pHead->next->prev = newnode;
    pHead->next = newnode;
    newnode->prev = pHead;

}

双向链表尾删：
 

void ListPopBack(ListNode* pHead)
{
    assert(pHead);
    ListNode* frist = pHead->next;
    ListNode* tail = pHead;
    while (frist->next!= pHead)
    {
        tail = tail->next;
        frist = frist->next;
    }
    tail->next = pHead;
    pHead->prev = tail;
    free(frist);
    frist = NULL;
}

双向链表头删：
 

void ListPopFront(ListNode* pHead)
{
    assert(pHead);
    ListNode* next = pHead->next;
    ListNode* next2 = next->next;
    pHead->next = next2;
    next2->prev = pHead;
    free(next);
}

双向链表查找：

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
    assert(pHead);
    int a = 0;
    ListNode* tail = pHead->next;
    while (tail->next != pHead)
    {
        a++;
        if (pHead->data == x)
        {
            printf("已经找到数据:%d", a);
            break;
        }
        else
        {
            printf("未找到数据");
            break;
        }
            
        tail=tail->next;
    }
}

 双向链表在pos的前面进行插入：

void ListInsert(ListNode* pos, LTDataType x);
{
	assert(pos);
	ListNode* newnode = BuyLTNode(x);
	ListNode* posprev = pos->prev;
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;

}

双向链表删除pos位置的节点：

void ListErase(ListNode* pos);
{
	assert(pos);
	ListNode* posnext = pos->next;
	ListNode* posprev = pos->prev;
	posnext->prev = posprev;
	posprev->next = posnext;
}

单链表与带头双向链表的优缺点：

单向链表：只有一个指向下一个节点的指针。

优点：单向链表增加删除节点简单。遍历时候不会死循环；

缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。

适用于节点的增加删除。

双向链表：有两个指针，一个指向前一个节点，一个后一个节点。

优点：可以找到前驱和后继，可进可退；

缺点：增加删除节点复杂，需要多分配一个指针存储空间。

适用于需要双向查找节点值的情况。