带头的双向链表

数据结构

双向链表的每一个节点有两个指针，一个指针指向上一个节点，一个指针指向下一个节点；还有一个有效数据
代码:

typedef int LTDataType;//数据类型
typedef struct ListNode
{
	struct ListNode* next;//链接下一个节点
	struct ListNode* prev;//链接上一个节点

	LTDataType data;//数据
}ListNode;

带头的双向链表的数据结构相对来说比较复杂
大致的逻辑结构如下：

若只有头节点：这种情况就是该头节点的next指针和prev指针都链接自己

函数接口

ListNode* BuyListNode(LTDataType x);//创建新节点
ListNode* LTInit(void);//初始化
void LTPrint(ListNode* phead);//打印
void LTDestory(ListNode* phead); //销毁 
void LTPushBack(ListNode* phead, LTDataType x);//尾插
void LTPopBack(ListNode* phead); //尾删
bool LTEmpty(ListNode* phead);//判断链表是否为空
void LTPushfront(ListNode* phead, LTDataType x);//头插
void LTPopfront(ListNode* phead);//头删
void LTInsert(ListNode* pos, LTDataType x);//任意位置之前插入
void LTErase(ListNode* pos);//任意位置的删除
ListNode* LTFind(ListNode* phead, LTDataType x);//查找：
//找到返回x对应节点的指针，找不到返回NULL

函数实现

创建新节点

因为头插、尾插 以及初始化都需要创建新节点，不妨写一个函数来实现这一操作，来减少代码的冗余性。
创建新节点：首先开辟空间，然后再将两指针置为NULL,以及要初始化的数据
代码:

ListNode* BuyListNode(LTDataType x)//创建新节点
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("ButListNode malloc\n");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

初始化

有前面的解释，那么双向链表的初始化也就很好实现了：

ListNode* LTInit()//初始化(只有一个节点)
{
	ListNode* phead = BuyListNode(-1);
	phead->prev = phead;//指向自己
	phead->next = phead;//指向自己
	return phead;
}

打印

打印比较简单，就是单纯遍历链表，打印数据，我用<=>来表示两个节点之间的关系
代码：

void LTPrint(ListNode* phead)//打印
{
	assert(phead);
	ListNode* cur = phead->next;//从第一个节点遍历
	while (cur != phead)//当cur=head证明cur已经遍历完一圈
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}	
}

尾插

因为是双向循环链表，头节点的上一个节点链接的就是尾节点，所以不需要遍历链表来找尾节点

有了尾节点尾插就简单了，但是尾插结束后的数据结构还要符合双向循环链表的结构

大致是这样的详细看代码

void LTPushBack(ListNode* phead, LTDataType x)//尾插
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* tail = phead->prev;//尾指针就是头指针的上一个节点
	//修改4个指针
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

判断链表是否为空

直接判断头节点是否指向自己即可
直接上代码：

bool LTEmpty(ListNode* phead)//判断链表是否为空
{
	assert(phead);
	return phead->next == phead;//为空返回true 不为空返回false
}

尾删

大致思路就是找到尾节点的前一个节点，然后在修改两个指针就OK了
直接上代码：

void LTPopBack(ListNode* phead) //尾删
{
	assert(phead);
	assert(!LTEmpty(phead));
	ListNode* tail = phead->prev;//找尾节点
	ListNode* tailprev = tail->prev;//找尾节点的前一个
	//只需要改两个指针
	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
	tail = NULL;
}

头插

细节看代码：

void LTPushfront(ListNode* phead,LTDataType x)//头插
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	//下面两组不可随便换顺序
	phead->next->prev = newnode;
	newnode->next = phead->next;

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

任意位置的插入

大体思路和头插差不多，就不画图了直接上代码：

void LTInsert(ListNode* pos, LTDataType x)//任意位置之前插入
{
	assert(pos);

	ListNode* newnode = BuyListNode(x);
	//顺序不能交换
	pos->prev->next = newnode;
	newnode->prev = pos->prev;

	newnode->next = pos;
	pos->prev = newnode;
	
}

任意位置的删除

思路就是用pos该位置去寻找pos前一个节点，然后将pos前一个节点和pos后一个节点的关系搞好，然后再删除pos节点即可

void LTErase(ListNode* pos)//任意位置的删除
{
	assert(pos);
	//ListNode* del = pos;
	//顺序不可换
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
	pos = NULL;
}

查找

直接上代码：

ListNode* LTFind(ListNode* phead, LTDataType x)//查找：
//找到返回x对应节点的指针，找不到返回NULL
{
	assert(phead);
	//从哨兵位置的后一个节点遍历，也就是有效数据的第一个节点
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
			cur = cur->next;
	}
	return NULL;//链表遍历完都没有找到 就返回NULL
}

销毁

就是遍历链表一个一个删除，需要注意的就是结束标志的判断，因为他是环状结构
直接上代码：

void LTDestory(ListNode*phead)//销毁
{
	assert(phead);
	//因为如果从哨兵位置开始删除不好判断结束标志，所以我们从有效数据的第一个节点开始删除
	ListNode* cur = phead->next;

	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);//此时cur为pheads哨兵位置，再释放哨兵节点就好了
	//phead = NULL;
	//切记：函数外一点要将传入的实参置为NULL,防止野指针的形成
}