拿来吧！C语言数据结构-带头双向循环链表

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了

链表初始化

首先创建一个结构体，给上前驱指针，后驱指针，还有数据域。

typedef int LTDateType;//数据类型
typedef struct ListNode
{
	LTDateType data;//数据域
	struct ListNode * next;//后驱指针
	struct ListNode * prev;//前去指针
}LTNode;

然后我们需要初始化函数来初始化链表，先创建一个头结点，让头结点的前驱指针和后驱指针都指向自己来实现循环。

LTNode* BuySListNode(LTDateType x)
{
	//开辟结点
	LTNode *node = (LTNode *)malloc(sizeof(LTNode));
	//判断是否成功开辟
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);//退出程序
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}
//初始化
LTNode* ListInit()
{
	LTNode *phead = BuySListNode(0);//头结点
	phead->next = phead;//后驱指向自己
	phead->prev = phead;//前驱指向自己
	return phead;
}

尾插

双向链表就比单向的很方便，单向链表就要先去找尾，这里就是head->prev.

void ListPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
	//记录前一个结点
	LTNode *tail = phead->prev;
	LTNode *newnode = BuySListNode(x);
	//建立链接关系
	tail->next = newnode;	
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

链表的打印

// 双向链表打印
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode *cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

测试一下尾插

void test()
{
	LTNode *plist = NULL;
	plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);
}

尾删

在尾删的时候，我们一直删一直删当链表没有结点还在删除就会出现问题。这是我们给个Empty的函数，配合assert一起使用就能解决这个问题。

bool ListEmpty(LTNode *phead)
{
	assert(phead);
	return phead->next == phead;
}

void ListPopBack(LTNode *phead)
{
	assert(phead);
	//没有结点就不能在删除了
	assert(!ListEmpty(phead));
	//先找到尾,在记录它前一个结点
	LTNode *tail = phead->prev;
	LTNode *tailprev = tail->prev;
	free(tail);
	tail = NULL;
	//在修改链接关系
	phead->prev = tailprev;
	tailprev->next = phead;
}

	ListPopBack(plist);
	ListPrint(plist);

当我们一直删，删完还在继续删就会报错。

头插

//头插
void ListPushFront(LTNode *phead, LTDateType x)
{
	assert(phead);
	
	LTNode *newnode = BuySListNode(x);
	//记录phead的后一个结点
	LTNode *next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

在头插个10

	ListPushFront(plist, 10);
	ListPrint(plist);

头删

void ListPopFront(LTNode *phead)
{
	assert(phead);
	//没有结点就不能在删除了
	assert(!ListEmpty(phead));
	LTNode *tail = phead->next;
	phead->next = tail->next;
	tail->prev = phead;
	free(tail);
	tail = NULL;
}

	ListPopFront(plist);
	ListPrint(plist);

查找

查找，和打印链表差不多。

// 双向链表查找
LTNode* ListFind(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode *cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

在pos之前插入结点

//在pos位置之前插入结点
void LTInsert(LTNode* pos, LTDateType x)
{
	assert(pos);
	//记录pos的前一个结点
	LTNode *prev = pos->prev;
	LTNode *newnode = BuySListNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

	LTNode * pos = ListFind(plist, 3);
	if (pos)
	{
		LTInsert(pos, 30);
	}
	ListPrint(plist);

在3之前插个30

那之前的头插和尾插就可以复用

删除pos位置的结点

void ListErase(LTNode* pos)
{
	assert(pos);
	//记录pos的前一个结点和后一个结点
	LTNode *prev = pos->prev;
	LTNode *next = pos->next;
	free(pos);
	pos = NULL;
	prev->next = next;
	next->prev = prev;
}

	LTNode * pos = ListFind(plist, 3);
	if (pos)
	{
		ListErase(pos);
	}
	ListPrint(plist);

3就被干掉了。
那同样头删和尾删也可以复用。

链表的销毁

最后一定要销毁。
一个一个结点的释放。

// 双向链表销毁
void ListDestory(LTNode* phead)
{
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}

	free(phead);
}

这些就是带头双向链表经常使用的，比单链表用起来很方表。但是面试考的多的是单链表，因为单链表的很麻烦。