数据结构——双向循环带头结点链表

1.双向循环带头结点链表的结构图：

prev：指向前一个结点的指针名

next：指向下一个结点

一个头指针指向头结点，之后的每个结点都有两个指针一个指针(prev)指向前一个结点，另一个指针(next)指向下一个结点，头节点的prev指向尾结点，尾结点的next指向头结点 (逻辑结构如上图)

 以下是结构体的定义

typedef int ELemType;        //将int类型别名为ElemType 之后的所有变量值都叫ElemType
typedef struct ListNode     //别名的好处是 以后要更改为别的类型的变量 更改这一句即可
{
	ELemType data;
	struct ListNode* prev;		//指向前一个结点  
	struct ListNode* next;		//指向后一个结点
}ListNode;                    

以下是我们所要写的接口（增删查改等）

ListNode* BuyListNode(ELemType x);//创建一个新的结点

ListNode* ListInit();//对(头)结点的初始化，并返回这个结点的指针

ListNode* ListDestory(ListNode* phead);//销毁所有结点 需要用户手动将头指针置空

void ListPrint(ListNode* phead);//打印 方便查看结果

void ListPushback(ListNode* phead, ELemType x);//尾部插入

void ListPopback(ListNode* phead);//尾部删除

void ListPushfront(ListNode* phead, ELemType x);//头部插入

void ListPopfront(ListNode* phead);//头部删除

void ListInsertPos(ListNode* pos, int x);//在某个位置插入

void ListErasePos(ListNode* pos);	//在某个位置删除

ListNode* ListFind(ListNode* phead, ELemType x);//找到和x相同的数据的位置并返回

bool ListEmpty(ListNode* phead);	//判断是否为空

int ListSize(ListNode* phead);		//计算链表的元素个数

ListNode* ListDestory(ListNode* phead);	//销毁链表

2.在程序的开始我们需要创建一个头结点并将这个结点的地址返回：初始化 ListInit

由于在多个接口中都存在新建一个结点，我们将创建结点也做成一个接口：BuyList

ListNode* BuyList(ELemType x) 
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->data = x;			//	存入想要为里存的数据
	newnode->next = NULL;		
	newnode->prev = NULL;		
	return newnode;
}

ListNode* ListInit() 
{
	ListNode* phead = BuyList(0);
	phead->prev =phead->next;		//因为是一个循环结构所以头结点初始化
	phead->next = phead->prev;		//next和prev都指向自己，构成闭环
	return phead;
}

3.尾插和尾删

有个问题怎么才能找到链表的尾部？

答：头结点的前一个其实就是整个链表的尾部，尾部的下一个就是链表的头部，所以我们很方便就能找到尾，相比单链表就简单得多了

插入

第一步 先创建一个新的结点   我把他命名为newnode

第二步  将链表当前的最后一个结点(tail)的next指向newnode,newnode的prev指向tail

第三步  将newnode的next和head链接  head的prev指向newnode

void ListPushback(ListNode* phead, ELemType x) 
{
	assert(phead);        //防止传入的是空
	ListNode* newnode = BuyList(x);
	ListNode* tail = phead->prev;   //找到尾
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

删除

第一步 将tail结点的上一个结点的next指向头结点，头结点的prev指向tail点的上一个结点

第二部 free掉tail结点

 

注意！！在删到头结点的时候就不要删了 所以有 assert(phead->next != phead);来控制

如果删除的下一个是头结点我就退出程序

void ListPopback(ListNode* phead) 
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* tail = phead->prev;
	ListNode* tailprev = tail->prev;
	free(tail);
	tailprev->next = phead;
	phead->prev = tailprev;
}

 如果删多了则会如下

4.打印

完成了上述的操作 我们应该怎么验证呢？

最主要的方法就是打印出来 看看是否和我们想的一致

主要的方式就是从头开始遍历   注意！！！不包含头结点 我们定义first代表第一个结点，当该结点等于我们的头结点时就跳出循环

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

测试一下我们写的接口是否正确

void test2()
{
	ListNode* head = ListInit();
	ListPushback(head, 1);
	ListPushback(head, 2);
	ListPushback(head, 3);
	ListPushback(head, 4);
	ListPrint(head);
	ListPopback(head);
	ListPopback(head);
	ListPrint(head);
}
int main() 
{
	test2();
	return 0;
}

结果正确 我们进行了 尾部插入 和删除

5.头插和头删

头插

第一步 创建一个新的结点newnode，再把新结点的next链接到first结点，newnode的prev链接到头结点

第二步 first结点的prev链接到newnode，头结点的next链接到newnode

这样newnode就变成了新的first，在下一次插入操作是相同的

 代码如下：

void ListPushfront(ListNode* phead, ELemType x) 
{
	assert(phead);
	ListNode* newnode = BuyList(x);
	ListNode* first = phead->next;
	newnode->next = first;
	newnode->prev = phead;
	first->prev = newnode;
	phead->next = newnode;
}

头删

第一步 先将头结点的next指向first的next，first的下一个结点的前指针prev指向头结点，他俩就链接上了

第二步 free掉first结点

注意！！一定要先将头结点和first的下一个结点链接  如果先free掉first 则会找不到 first的下一个结点        同样我们要注意删除到头结点时我们就不能继续删除了 直接退出程序

void ListPopFront(ListNode* phead) 
{
	assert(phead != NULL);
	assert(phead->next != phead);
	ListNode* first = phead->next;
	ListNode* second = first->next;
	phead->next = second;
	second->prev = phead;
	free(first);
}

头部的数据则被删除掉了

6.在给定的位置(pos)处插入数据和删除数据

插入

第一步创建新的结点   新的结点的prev链接pos前一个结点  next链接到pos结点

第二部 pos前一个结点 的 next链接newnode ，pos的prev链接到新结点

void ListInsertPos(ListNode* pos, int x) 
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* newnode = BuyListNode(x);
	newnode->next = pos;
	newnode->prev = prev;
	pos->prev = newnode;
	prev->next = newnode;
}

 如果在头部插入的话 那么这个新的结点就变成了尾 相当于尾插 同理 如果在头结点的下一个插入的话则变成了头插 我们则可以代码复用  前面写的头插尾插  则可以用这一个代替代码如下

 

 

void ListPushback(ListNode* phead, ELemType x) 
{
	//assert(phead);
	//ListNode* newnode = BuyListNode(x);
	//ListNode* tail = phead->prev;   //找尾
	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;

	ListInsertPos(phead->prev, x);
}

void ListPushfront(ListNode* phead, ELemType x)
{
	/*assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* first = phead->next;
	phead->next = newnode;
	newnode->next = first;
	newnode->prev = phead;
	first->prev = newnode;*/
	ListInsertPos(phead->next, x);
}

在pos位置删除

void ListErasePos(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

当然头删和尾删都可以复用这段代码

void ListPopback(ListNode* phead) 
{
	assert(phead);
	assert(phead->next != phead);
	/*ListNode* tail = phead->prev;
	ListNode* tailprev = tail->prev;
	free(tail);
	tailprev->next = phead;
	phead->prev = tailprev;*/
	ListErasePos(phead->prev);

}
void ListPopfront(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	/*ListNode* first = phead->next;
	ListNode* second = first->next;
	free(first);
	phead->next = second;
	second->prev = phead;*/
	ListErasePos(phead->next);
}

7.ListFind查找某个值的地址位置并返回这个地址

ListNode* ListFind(ListNode* phead, ELemType x)
{
	ListNode* cur = phead->next;
	while (cur!=phead) 
	{
		if (cur->data == x) 
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

8.判断链表内是否为空 是为1 不是为0

bool ListEmpty(ListNode* phead) 
{
	assert(phead);
	if (phead->next != phead)
		return false;
	return true;
}

9.返回链表元素个数

int ListSize(ListNode* phead) 
{
	int count = 0;
	ListNode* cur = phead->next;
	while (cur != phead) 
	{
		++count;
		cur = cur->next;
	}
	return count;
}

10.销毁链表

ListNode* ListDestory(ListNode* phead) 
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur!=phead) 
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

这里我们需要注意，我们把所有的结点都free了，此时的头指针就变成了野指针，我们应该让他变成空，所有要在函数的外部置空 head=NULL；