数据结构——带头双向循环链表的实现

作者：小 琛
欢迎转载，请标明出处
引言：
带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单。

带头双向循环链表的逻辑

故名思意：这种链表有几个特征
1、带头，通过前面对不带头单链表的学习，我们能理解当一个链表有头时，往往会方便很多
2、双向，单链表的一个最不方便的点就是我们无法得到当前节点的上一个节点，而双链表则具备了这个功能
3、循环，为了保证能直接得到一个链表的尾节点
逻辑如下图：

基本功能实现

双链表实现头插、尾插、头删、尾删等功能非常简单，只要细心的进行画图，编写逻辑即可，这里暂画一个尾插的逻辑图

其它的本博文就不一一进行画图，直接写完整代码

List.h文件

#ifndef _LIST_H_
#define _LIST_H_
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int DateType;

typedef struct ListNode
{
	DateType _date;
	struct ListNode* _next;
	struct ListNode* _prev;

}ListNode;

ListNode* CreateHead();
ListNode* CreateNode(DateType x);
void EraseList(ListNode** plist);
void PopList(ListNode* plist);
void ListPrint(ListNode* plist);
void PushBack(ListNode* plist, DateType x);
void PushFront(ListNode* plist, DateType x);
void PopBack(ListNode* plist);
void PopFront(ListNode* plist);
ListNode* ListFind(ListNode* plist, DateType x);
void ListInsert(ListNode* pos, DateType x);
void ListErase(ListNode* pos);

#endif

List.c

#include "List.h"
/*
函数功能：创立一个头节点
入口参数：无
返回值：头节点的地址
*/
ListNode* CreateHead()
{
	ListNode* newhead = (ListNode*)malloc((sizeof(ListNode)));
	newhead->_next = newhead;
	newhead->_prev = newhead;
	return newhead;
}
/*
函数功能：创立一个新的节点，并赋予_date新值
入口参数：要赋予的值
返回值：新节点的地址
*/
ListNode* CreateNode(DateType x)
{
	ListNode* newnode = (ListNode*)malloc((sizeof(ListNode)));
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_date = x;
	return newnode;
}
/*
函数功能：删除链表
入口参数：该链表头的地址
返回值：无
*/
void EraseList(ListNode** plist)
{
	assert(plist);
	ListNode* head = (*plist);
	ListNode* cur = ((*plist));
	ListNode* tmp = ((*plist)->_next);
	if (tmp == head)
	{
		;
	}
	else
	{
		while (tmp != head)
		{
			cur = tmp;
			tmp = tmp->_next;
			free(cur);

		}
		tmp = NULL;
	}
	(*plist)->_next = (*plist);
	(*plist)->_prev = (*plist);
}
/*
函数功能：打印函数
入口参数：链表的头节点
返回值：无
*/
void ListPrint(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->_next;
	while (cur != plist)
	{
		printf("%d\n", cur->_date); 
		cur=cur->_next;
	}
	printf("NULL");
	printf("\n");
	printf("\n");
}
/*
函数功能：尾插
入口参数：链表头节点、要插入的值
返回值：无
*/
void PushBack(ListNode* plist, DateType x)
{
	assert(plist);
	ListNode* newnode = CreateNode(x);
	if (plist->_next == plist)
	{
		plist->_next = newnode;
		plist->_prev = newnode;
		newnode->_next = plist;
		newnode->_prev = plist;
	}
	else
	{
		newnode->_next = plist->_prev->_next;
		newnode->_prev = plist->_prev;
		plist->_prev->_next = newnode;
		newnode->_next->_prev = newnode;
	}

}
/*
函数功能：头插
入口参数：链表头节点地址、要插入的值
返回值：无
*/
void PushFront(ListNode* plist, DateType x)
{
	assert(plist);
	ListNode* newnode = CreateNode(x);
	plist->_next->_prev = newnode;
	newnode->_next = plist->_next;
	plist->_next = newnode;
	newnode->_prev = plist;
}
/*
函数功能：尾删
入口参数：链表头节点
返回值：无
*/
void PopBack(ListNode* plist)
{
	assert(plist);
	if (plist->_next == plist)
	{
		;
	}
	else
	{
		ListNode* cur = plist->_prev;
		plist->_prev->_prev->_next = plist;
		plist->_prev = plist->_prev->_prev;
		free(cur);
		cur = NULL;
	}
}
/*
函数功能：头删
入口参数：链表头节点
返回值：无
*/
void PopFront(ListNode* plist)
{
	assert(plist);
	if (plist->_next == plist)
		;
	else
	{
		ListNode* cur = plist->_next;
		plist->_next->_next->_prev = plist;
		plist->_next = plist->_next->_next;
		free(cur);
		cur = NULL;
	}
}
/*
函数功能：查找函数
入口参数：链表头节点、要寻找的值
返回值：所查找的值在链表中的第一个节点地址
*/
ListNode* ListFind(ListNode* plist, DateType x)
{
	assert(plist);
	ListNode* cur = plist->_next;
	while (cur->_date != x)
	{
		cur = cur->_next;
	}
	return cur;
}
/*
函数功能：插入函数
入口参数：要插入的节点地址、要插入的值
返回值：无
*/
void ListInsert(ListNode* pos, DateType x)
{
	assert(pos);
	ListNode* newnode = CreateNode(x);
	newnode->_next = pos;
	newnode->_prev = pos->_prev;
	pos->_prev = newnode;
	newnode->_prev->_next = newnode;
}
/*
函数功能：删除节点寒素
入口参数：链表头地址
返回值：无
*/
void ListErase(ListNode* pos)
{
	assert(pos);
	pos->_next->_prev = pos->_prev;
	pos->_prev->_next = pos->_next;
	free(pos);
}

text.c

#include "List.h"

void text1()
{
	ListNode* head = CreateHead();
	PushBack(head, 1);
	PushBack(head, 2);
	PushBack(head, 3);
	PushBack(head, 4);
	PushBack(head, 5);
	ListPrint(head);
	PopBack(head);
	ListPrint(head);
	EraseList(&head);
	ListPrint(head);
}
void text2()
{
	ListNode* head = CreateHead();
	PushFront(head, 1);
	PushFront(head, 2);
	PushFront(head, 3);
	PushFront(head, 4);
	ListPrint(head);
	PopFront(head);
	ListPrint(head);

	EraseList(&head);
	ListPrint(head);

}
void text3()
{
	ListNode* head = CreateHead();
	ListNode* cur = NULL;
	PushBack(head, 1);
	PushBack(head, 2);
	PushBack(head, 3);
	PushBack(head, 4);
	ListPrint(head);
	cur=ListFind(head, 2);
	ListPrint(cur);

}
void text4()
{
	ListNode* head = CreateHead();
	ListNode* cur = NULL;
	PushBack(head, 1);
	PushBack(head, 2);
	PushBack(head, 3);
	PushBack(head, 4);
	ListPrint(head);
	cur = ListFind(head,2);
	ListInsert(cur, 6);
	ListPrint(head);
	cur = ListFind(head, 6);
	ListErase(cur);
	ListPrint(head);
}
int main()
{
	text4();
	return 0;
}

感谢浏览