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

带头双向循环链表简介

带头双向循环链表结构如下：

带头双向链表的特点：

• 空链表不是没有结点，而是有一个头结点的链表，此时头结点的前后指针都指向自己，且头结点中存储的元素非链表中的有效元素。
• 带头双向循环链表的头删，是删除头结点的下一个结点，而非head结点。
• 带头双向循环链表的尾删，无需遍历该链表去寻找最后一个结点，因为头结点指向的前一个节点就是最后一个结点。

带头双向循环链表的定义及功能实现

/dclist.h
#pragma once
#include"commen.h"

typedef struct DCListNode
{
	ElemType data;
	struct DCListNode* prev;
	struct DCListNode* next;
}DCListNode;

typedef DCListNode* DCList;

DCListNode* BuyNode(ElemType v);//申请一个结点
void DCListInit(DCList* phead);//链表初始化
void DCListDestroy(DCList* phead);//链表销毁
void DCListShow(DCList phead);//打印链表
void DCListPushBack(DCList* phead, ElemType x);//尾插
void DCListPushFront(DCList* phead, ElemType x);//头插
void DCListPopBack(DCList* phead);//尾删
void DCListPopFront(DCList* phead);//头删
size_t DCListLength(DCList phead);//链表长度
DCListNode* DCListFind(DCList phead, ElemType key);//查找链表中某一指定元素
void DCListEraseByVal(DCList* phead, ElemType key);//删除链表中，某一指定圆度
void DCListSort(DCList* phead);//链表的排序
void DCListInsertByVal(DCList* phead, ElemType x);//按照值得大小插入有序的链表中
ElemType DCListFront(DCList* phead);//获取头部元素
ElemType DCListBack(DCList* phead);//获取尾部元素
void DCListEraseAll(DCList* phead, ElemType x);//删除链表中某一指定元素的所有(包括重复值)
void DCListClean(DCList* phead);//清理链表
void DCListReverse(DCList* phead);//链表的逆置

/

DCListNode* BuyNode(ElemType v)
{
	DCListNode* node = (DCListNode*)malloc(sizeof(DCListNode));
	assert(node != NULL);
	node->data = v;
	node->next = node->prev = node;
	return node;
}
void DCListInit(DCList* phead)
{
	*phead = BuyNode(0);
}
void DCListDestroy(DCList* phead)
{
	assert(phead != NULL);
	DCListClean(phead);
	free(*phead);
	*phead = NULL;
}
void DCListShow(DCList phead)
{
	DCListNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("over\n");
}
void DCListPushBack(DCList* phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode* node = BuyNode(x);

	node->prev = (*phead)->prev;
	node->next = *phead;
	node->prev->next = node;
	(*phead)->prev = node;
}
void DCListPushFront(DCList* phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode* node = BuyNode(x);

	node->next = (*phead)->next;
	node->prev = *phead;
	(*phead)->next = node;
	node->next->prev = node;
}
void DCListPopBack(DCList* phead)
{
	assert(phead != NULL);
	DCListNode* tail = (*phead)->prev;
	if (tail == (*phead))
		printf("当前链表中没有有效结点，无法进行尾删操作\n");
	else
	{
		(*phead)->prev = tail->prev;
		tail->prev->next = *phead;
		free(tail);
		tail = NULL;
	}
}
void DCListPopFront(DCList* phead)
{
	assert(phead != NULL);
	DCListNode* first = (*phead)->next;
	if(first == (*phead))
		printf("当前链表中没有有效结点，无法进行头删操作\n");
	else
	{
		(*phead)->next = first->next;
		first->next->prev = *phead;
		free(first);
		first = NULL;
	}
}
size_t DCListLength(DCList phead)
{
	assert(phead != NULL);
	DCListNode* cur = phead->next;

	size_t len = 0;
	while (cur != phead)
	{
		++len;
		cur = cur->next;
	}
	return len;
}
DCListNode* DCListFind(DCList phead, ElemType key)
{
	assert(phead != NULL);
	DCListNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == key)
			return cur;
		cur = cur->next;
	}
	return NULL;
}
void DCListEraseByVal(DCList* phead, ElemType key)
{
	assert(phead != NULL);
	DCListNode* cur = (*phead)->next;
	while (cur != *phead && cur->data != key)
	{
		cur = cur->next;
	}
	if (cur == *phead)
	{
		printf("链表中没有此元素，无法进行删除\n");
	}
	else
	{
		cur->prev->next = cur->next;
		cur->next->prev = cur->prev;
		free(cur);
		cur = NULL;
	}
}
void DCListSort(DCList* phead)
{
	assert(phead != NULL);

	if (DCListLength(*phead) == 1)
		return;
	DCListNode* p = (*phead)->next;
	DCListNode* q = p->next;

	p->next = *phead;
	(*phead)->prev = p;

	DCListNode* cur = p;
	while (q != *phead)
	{
		p = q;
		q = q->next;
		while (cur != *phead && cur->data < p->data)
			cur = cur->next;
		p->next = cur;
		p->prev = cur->prev;
		cur->prev = p;
		p->prev->next = p;

		cur = (*phead)->next;
	}
}
void DCListInsertByVal(DCList* phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode* node = BuyNode(x);
	DCListNode* cur = (*phead)->next;
	while (cur != *phead && cur->data < x)
		cur = cur->next;
	node->next = cur;
	node->prev = cur->prev;
	node->prev->next = node;
	node->next->prev = node;
}
ElemType DCListFront(DCList* phead)
{
	assert(phead != NULL);
	DCListNode* first = (*phead)->next;
	if (first == *phead)
		return -1;
	return first->data;
}
ElemType DCListBack(DCList* phead)
{
	assert(phead != NULL);
	DCListNode* tail = (*phead)->prev;
	if (tail == *phead)
		return -1;
	return tail->data;
}
void DCListEraseAll(DCList* phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode* cur = (*phead)->next;
	while (cur != (*phead))
	{
		if (cur->data == x)
		{
			DCListNode* pre = cur->prev;
			cur->prev->next = cur->next;
			cur->next->prev = cur->prev;
			free(cur);
			cur = pre;
		}
		cur = cur->next;
	}
}
void DCListReverse(DCList* phead)
{
	assert(phead != NULL);

	if (DCListLength(*phead) == 1)
		return;
	DCListNode* p = (*phead)->next;
	DCListNode* q = p->next;

	p->next = *phead;
	(*phead)->prev = p;

	while (q != *phead)
	{
		p = q;
		q = q->next;

		p->next = (*phead)->next;
		p->prev = *phead;
		(*phead)->next = p;
		p->next->prev = p;
	}
}
void DCListClean(DCList* phead)
{
	assert(phead != NULL);
	DCListNode* head = *phead;
	DCListNode* cur = head->next;
	while (cur != head)
	{
		cur->prev->next = cur->next;
		cur->next->prev = cur->prev;
		free(cur);
		cur = head->next;
	}
}

带头双向循环链表的功能测试模块

/test.c
#define _CRT_SECURE_NO_WARNINGS
#include"commen.h"
#include"dclist.h"

int main()
{
	DCList list;
	DCListInit(&list);

	DCListNode* p = NULL;
	ElemType item;
	int select = 1;
	size_t pos;
	while (select)
	{
		printf("**************************************************\n");
		printf("***********************MENU***********************\n");
		printf("*  [1]push_back                   [2]push_front  *\n");
		printf("*  [3]show_list                   [0]quit_system *\n");
		printf("*  [4]pop_back                    [5]pop_front   *\n");
		printf("*  [6]insert_val                  [7]erase_val   *\n");
		printf("*  [8]find                        [9]length      *\n");
		printf("*  [10]earse_all                  [11]sort       *\n");
		printf("*  [12]reverse                    [13]clean      *\n");
		printf("*  [14]front                      [15]back       *\n");
		printf("**************************************************\n");
		printf("**************************************************\n");
		printf("请选择->\n");
		scanf("%d", &select);
		if (select == 0)
			break;
		switch (select)
		{
		case 0:
			select = 0;
			break;
		case 1:
			printf("请输入要插入的元素，若要退出，输入-1->\n");
			while (scanf("%d", &item), item != -1)
			{
				DCListPushBack(&list, item);
			}
			break;
		case 2:
			printf("请输入要插入的元素，若要退出，输入-1->\n");
			while (scanf("%d", &item), item != -1)
			{
				DCListPushFront(&list, item);
			}
			break;
		case 3:
			DCListShow(list);
			break;
		case 4:
			DCListPopBack(&list);
			break;
		case 5:
			DCListPopFront(&list);
			break;
		case 6:
			printf("请输入要插入的元素->\n");
			scanf("%d", &item);
			DCListSort(&list);
			DCListInsertByVal(&list, item);
			break;
		case 7:
			printf("请输入要删除的元素->\n");
			scanf("%d", &item);
			DCListEraseByVal(&list, item);
			break;
		case 8:
			printf("请输入要查找的元素->\n");
			scanf("%d", &item);
			p = DCListFind(list, item);
			if (p == NULL)
				printf("元素%d不存在\n", item);
			else
				printf("元素%d所在的位置为%d\n", item, p);
			break;
		case 9:
			printf("length = %d\n", DCListLength(list));
			break;
		case 10:
			printf("请输入要删除的元素->\n");
			scanf("%d", &item);
			DCListEraseAll(&list, item);
			break;
		case 11:
			DCListSort(&list);
			break;
		case 12:
			DCListReverse(&list);
			break;
		case 13:
			DCListClean(&list);
			break;
		case 14:
			if (DCListFront(&list) == -1)
				printf("该顺序表为空，无法获取其头部元素\n");
			else
				printf("头元素为%d\n", DCListFront(&list));
			break;
		case 15:
			if (DCListBack(&list) == -1)
				printf("该顺序表为空，无法获取其尾部元素\n");
			else
				printf("末尾元素为%d\n", DCListBack(&list));
			break;
		default:
			printf("输入非法，请重新选选择->\n");
			break;
		}
		system("pause");
		system("cls");
	}
	DCListDestroy(&list);
	return 0;
}