带头节点的双向带头循环链表

一.逻辑结构:

双向带头链表有一个数值域和两个指针域。一个头节点，前驱指向最后一个节点，后继指向第一个节点；每一个节点有一个前驱和一个后继，分别 指向前一个节点和后一个节点；链表的最后一个节点的后继指向链表的头节点。

二.功能：

双向带头链表中实现的功能有：初始化链表、头插、尾插、头删、尾删，在pos位置之前插入一个节点、删除pos位置的节点

三.链表的结构

#define LTDataType int;
typedef struct ListNode
{
//数值域
	LTDataType data;
//指针域（后继）
	struct ListNode* next;
//指针域（前驱）
	struct ListNode* prev;
}ListNode;

四.头文件声明

#pragma once
//带头双向链表，在任意位置插入删除的时间复杂度都是O(1),查找时为O(N)
#include<assert.h>
#include<stdio.h>
typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;

//初始化
ListNode* ListInit();
//销毁链表
void ListDestory(ListNode* plist);
//打印
void ListPrint(ListNode* plist);
//尾插
void ListPushBack(ListNode* plist, LTDataType x);
//头插
//void ListPushFront(ListNode* plist, LTDataType x);
void ListPushFront(ListNode* plist, LTDataType x);
//尾删
void ListPopBack(ListNode* phead);
//头删
void ListPopFront(ListNode* phead);
//开辟空间
ListNode* BuyListNode(LTDataType x);
//查找
ListNode* ListFind(ListNode* phead, LTDataType x);
//在pos位置之前插入x
void ListInsert(ListNode* pos, LTDataType x);
//删除pos位置的值
void ListErase(ListNode* pos);
//头插尾插，头删尾删都可以调用ListEnrase和ListInsert来实现

五.功能的实现：

**1. 开辟空间：**在实现其他功能之前，我们首先要开辟空间来存放链表的节点

ListNode* BuyListNode(LTDatatype x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	//将节点的数值域赋值为x
	phead->data = x;
	//将节点的前驱和后继置空
	phead->next = NULL;
	phead->prev = NULL;
	return newnode;
}

2.初始化链表：
我们需要在初始化中生成一个头节点，可以使用传参或返回值的方式得到头结点的地址
这里使用的是返回值的方式。

ListNode* ListInit()
{
//将头结点的数值域赋值为0，并且将其前驱后继置空
	ListNode* phead = BuyListNode(0);
	phead->next = NULL;
	phead->prev = NULL;
	return phead;
}

3.查找：
这个功能可以帮助我们找到节点的地址，也能帮助我们实现其他功能

//找到时返回cur，cur为数值x所在的节点的地址；没有找到或链表为空时返回NULL
ListNode* ListFind(ListNode* phead,TLDatatype x)
{
	assert(phead);
	//cur的地址为第一个节点的地址
	ListNode* cur = phead->next;
	/*当cur==phead时，链表已经被遍历了一次，没有找到，返回NULL;链表若
	为空,则返回NULL*/
	while(cur->next !=phead)
	{
		if(cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
	
}

4. 在pos位置之前插入一个节点：
我们先实现这个功能；头插的功能可以使用这段代码实现。

逻辑表示：

//pos为使用查找功能ListFind返回的地址
void ListInsert(ListNode* pos，LTDatatype x)
{
	assert(pos);
	ListNode* newnode = BuyListNode(x);
	pos->prev = prev;
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

5. 删除pos位置的节点：

逻辑表示：

ListNode* ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* next= pos->next;
	ListNodde* prev = pos->prev;
	prev->next = next;
	next->prev = prev;
	free(pos);
	pos=NULL;
}

6.头插：头插可以使用ListFinde和ListInsert辅助实现：

（1）基本实现：

void ListPushFront(ListNode* phead,LTDatatype x)
{
	ListNode* newnode = BuyListNode(x);
	ListNode* next = phead->next;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
	phead->next = newnode;
	
}

(2)ListInsert辅助实现：

//先使用ListFind找到第一个节点的位置pos
void ListPushFront(ListNode* phead,LTDataType x)
{
		ListNode* pos = phead->next;
		ListInsert(pos, x);
}

7. 尾插：
（1）基本实现：

void ListPushBack(ListNode* phead, LTDataType x)
{
	
	assert(phead);
	ListNode* tail = phead->prev;
	ListNode* newnode = BuyListNode(x);
	tail->next = newnode;

	newnode->prev = tail;
	newnode->next = phead;

	phead->prev = newnode;
	//在有头节点的情况下，即使链表中只有一个头节点，尾插也可以顺利进行。
}

（2）ListInsert辅助实现：

//如果通过调用ListInsert来实现尾插，则需要将pos设定在头节点的位置
void ListPushBack(ListNode* phead, LTDataType x)
{
	ListNode* pos = phead;
	ListInsert(pos, x);
}

8.头删
（1）基本实现：

void ListPopFront(ListNode* phead)
{
	assert(phead;)
	//判断链表是否为空
	if(phead->next !=phead)
	{
		//first为第一个节点，second为第二个节点
		ListNode* first=phead->next;
		ListNode* second = first->next;
		phead->next=second;
		second->prev=phead;
	}
	else
	{
		printf("链表为空，删除失败");
	}
	free(first);
	first=NULL;
	
	
}

逻辑表示：

（2）利用ListErase辅助实现：

void ListPopFront(ListNode* phead)
{
	assert(phead);
	if (phead->next == phead)
	{
		printf("链表为空");

	}
	else
	{
		ListNode* pos = phead->next;
		ListErase(pos);
	}
}

9.尾删
（1）基本实现：

	void ListPopBack(ListNode* phead)
	{
		assert(phead);
		if(phead->next !=phead)
		{
			ListNode* last = phead->prev;
			ListNode* last2 = last->prev;
			last2->next = phead;
			phead->prev = last2;
			free(last);
			last=NULL;
		}
	}

(2)利用ListErase实现：

void ListPopBack(ListNode* phead)
{
	assert(phead);
	if(phead->next !=phead)
	{
		ListNode* pos = phead->prev;
		ListErase(pos);
	}
}

10.销毁链表：

void ListDestory(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while(cur !=phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phaed=NULL;
	printf("链表销毁成功");
}

11.打印链表：

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