数据结构：双向带头循环链表的基本功能实现

概念

• 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。
• 它与单链表的最大区别就是每个节点可以指向该节点的前驱节点。链表为空时，至少还有一个头结点（该节点不存储有效数据，仅仅用来表示链表的头）。头结点的前驱与后继都是自己本身；链表不为空时，头结点的前驱就是尾结点，后继是第一个节点。尾结点的前驱是倒数第二个节点，后继是头结点所以整个链表是一个循环的，不存在指向空的节点.

创建一个新的节点

ListNode* BuyNewNode(x) {
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//为新节点申请空间
	if (NewNode == NULL) {//若空间申请失败，中止程序
		printf("申请空间失败！\n");
		assert(0);
	}
	NewNode->_data = x;//对新节点进行初始化
	NewNode->_next = NULL;
	NewNode->_prev = NULL;
	return NewNode;//返回新节点
}

创建一个新的链表

ListNode* ListCreate() {
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//为新节点申请空间
	if (NewNode == NULL) {//若空间申请失败，中止程序
		printf("申请空间失败！\n");
		assert(0);
	}
	NewNode->_data = 0;
	NewNode->_next = NewNode;
	NewNode->_prev = NewNode;
	return NewNode;
}

双向链表销毁

// 双向链表销毁
void ListDestory(ListNode* pHead) {
	assert(pHead);//链表判空
	ListNode* cur = pHead->_next;
	while (cur != pHead) {//释放每一个节点
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(pHead);//释放头结点(哨兵位节点)
}

双向链表打印

// 双向链表打印
void ListPrint(ListNode* pHead) {
	assert(pHead);//链表判空
	ListNode* cur = pHead->_next;//从第一个节点开始打印，遍历至头结点时结束
	while (cur != pHead) {
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}

双向链表尾插

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x) {
	assert(pHead);//链表判空
	ListInsert(pHead, x);//接口复用，头结点的前驱节点就是尾结点
}

双向链表尾删

// 双向链表尾删
void ListPopBack(ListNode* pHead) {
	assert(pHead);//链表判空
	ListErase(pHead->_prev);//接口复用，链表头指针的前驱节点就是尾结点
}

双向链表头插

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x) {
	assert(pHead);//链表判空
	ListInsert(pHead->_next, x);//接口复用，第一个位置前插入
}

双向链表头删

// 双向链表头删
void ListPopFront(ListNode* pHead) {
	assert(pHead);//链表判空
	ListErase(pHead->_next);//接口复用，删除第一个节点
}

双向链表查找

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead) {//遍历整个链表
		if (cur->_data == x) {//若找到，返回该节点
			return cur;
		}
		else {//否则遍历下一个节点
			cur = cur->_next;
		}
	}
	return NULL;//找不到，返回空
}

双向链表在pos的前面进行插入

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x) {
	ListNode* NewNode = BuyNewNode(x);
	ListNode* prev = pos->_prev;
	prev->_next = NewNode;
	NewNode->_prev = prev;
	NewNode
	->_next = pos;
	pos->_prev = NewNode;
}

双向链表删除pos位置的节点

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos) {
	ListNode* prev = pos->_prev;
	ListNode* next = pos->_next;
	free(pos);
	prev->_next = next;
	next->_prev = prev;
}

运行结果

完整代码

• doublelist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;


//创建一个新的节点
ListNode* BuyNewNode();
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

• doublelist.c

#include "doublelist.h"

ListNode* BuyNewNode(x) {
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//为新节点申请空间
	if (NewNode == NULL) {//若空间申请失败，中止程序
		printf("申请空间失败！\n");
		assert(0);
	}
	NewNode->_data = x;//对新节点进行初始化
	NewNode->_next = NULL;
	NewNode->_prev = NULL;
	return NewNode;//返回新节点
}
ListNode* ListCreate() {
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//为新节点申请空间
	if (NewNode == NULL) {//若空间申请失败，中止程序
		printf("申请空间失败！\n");
		assert(0);
	}
	NewNode->_data = 0;
	NewNode->_next = NewNode;
	NewNode->_prev = NewNode;
	return NewNode;
}
// 双向链表销毁
void ListDestory(ListNode* pHead) {
	assert(pHead);//链表判空
	ListNode* cur = pHead->_next;
	while (cur != pHead) {//释放每一个节点
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(pHead);//释放头结点(哨兵位节点)
}
// 双向链表打印
void ListPrint(ListNode* pHead) {
	assert(pHead);//链表判空
	ListNode* cur = pHead->_next;//从第一个节点开始打印，遍历至头结点时结束
	while (cur != pHead) {
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x) {
	assert(pHead);//链表判空
	ListInsert(pHead, x);//接口复用，头结点的前驱节点就是尾结点
}
// 双向链表尾删
void ListPopBack(ListNode* pHead) {
	assert(pHead);//链表判空
	ListErase(pHead->_prev);//接口复用，链表头指针的前驱节点就是尾结点
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x) {
	assert(pHead);//链表判空
	ListInsert(pHead->_next, x);//接口复用，第一个位置前插入
}
// 双向链表头删
void ListPopFront(ListNode* pHead) {
	assert(pHead);//链表判空
	ListErase(pHead->_next);//接口复用，删除第一个节点
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead) {//遍历整个链表
		if (cur->_data == x) {//若找到，返回该节点
			return cur;
		}
		else {//否则遍历下一个节点
			cur = cur->_next;
		}
	}
	return NULL;//找不到，返回空
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x) {
	ListNode* NewNode = BuyNewNode(x);
	ListNode* prev = pos->_prev;
	prev->_next = NewNode;
	NewNode->_prev = prev;
	NewNode->_next = pos;
	pos->_prev = NewNode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos) {
	ListNode* prev = pos->_prev;
	ListNode* next = pos->_next;
	free(pos);
	prev->_next = next;
	next->_prev = prev;
}

• test.c

#include "doublelist.h"

void test() {
	ListNode* s = ListCreate();
	ListPushBack(s, 3);
	ListPushBack(s, 4);
	ListPrint(s);
	ListPushFront(s, 2);
	ListPushFront(s, 1);
	ListPrint(s);
	ListPopBack(s);
	ListPrint(s);
	ListPopFront(s);
	ListPrint(s);
	ListNode* ret = ListFind(s, 3);
	printf("%d\n", ret->_data);
	ListInsert(ret, 5);
	ListPrint(s);
	ListErase(ret);
	ListPrint(s);
	ListDestory(s);
}

int main() {
	test();
	return 0;
}