循环双链表的基本运算算法（增删改查）

目的：领会循环双链表存储结构和掌握循环双链表中的各种基本运算算法。
如果双链表的操作会了，单链表那是手到擒来，很简单。

下面用一个实验来实现，该实现完成了以下功能：
1、初始化循环双链表h。
2、依次采用尾插法插入a、b、c、d、e五个元素。
3、输出循环双链表h。
4、输出循环双链表h的长度。
5、判断循环双链表是否为空。
6、输出循环双链表h的第3个元素。
7、输出元素a的位置。
8、在第4个元素的位置上插入f元素。
9、输出循环双链表h。
10、删除循环双链表h的第3个元素。
11、输出循环双链表h。
12、释放循环双链表h。

首先定义一个节点结构体DlinkNode和char类型ElemType

typedef int ElemType;
typedef struct DNode		//定义双链表结点类型
{
	ElemType data;
	struct DNode *prior;	//指向前驱结点
	struct DNode *next;		//指向后继结点
} DlinkNode;

尾插法和头插法创建循环双链表

void CreateListR(DlinkNode *&L,ElemType a[],int n) //尾插法建立循环双链表
{
	DlinkNode *s,*r;
	L=(DlinkNode *)malloc(sizeof(DlinkNode));  //创建头结点
	L->next=NULL;
	r=L;					//r始终指向尾结点,开始时指向头结点
	for (int i=0;idata=a[i];
		r->next=s;s->prior=r;	//将结点s插入结点r之后
		r=s;
	}
	r->next=L;				//尾结点next域指向头结点
	L->prior=r;				//头结点的prior域指向尾结点
}
void CreateListF(DlinkNode *&L,ElemType a[],int n) //头插法建立循环双链表
{
	DlinkNode *s;
	L=(DlinkNode *)malloc(sizeof(DlinkNode));  	//创建头结点
	L->next=NULL;
	for (int i=0;idata=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		if (L->next!=NULL) L->next->prior=s;
		L->next=s;s->prior=L;
	}
	s=L->next;	
	while (s->next!=NULL)			//查找尾结点,由s指向它
		s=s->next;
	s->next=L;						//尾结点next域指向头结点
	L->prior=s;						//头结点的prior域指向尾结点

}

初始化线性表

void InitList(DlinkNode *&L)	//初始化线性表
{
	L=(DlinkNode *)malloc(sizeof(DlinkNode));  	//创建头结点
	L->prior=L->next=L;
}

销毁线性表

void DestroyList(DlinkNode *&L)	//销毁线性表
{
	DlinkNode *pre=L,*p=pre->next;
	while (p!=L)
	{
		free(pre);
		pre=p;			//pre、p同步后移一个结点
		p=pre->next;
	}
	free(pre);			//此时p=L,pre指向尾结点,释放它
}

判线性表是否为空表

bool ListEmpty(DlinkNode *L)	//判线性表是否为空表
{
	return(L->next==L);
}

求线性表的长度

int ListLength(DlinkNode *L)	//求线性表的长度
{
	DlinkNode *p=L;
	int i=0;
	while (p->next!=L)
	{
		i++;
		p=p->next;
	}
	return(i);				//循环结束,p指向尾结点,其序号i为结点个数
}

输出线性表

void DispList(DlinkNode *L)	//输出线性表
{
	DlinkNode *p=L->next;
	while (p!=L)
	{
		printf("%c ",p->data);
		p=p->next;
	}
	printf("n");
}

求线性表中第i个元素值

bool GetElem(DlinkNode *L,int i,ElemType &e)	//求线性表中第i个元素值
{
	int j=1;
	DlinkNode *p=L->next;
	if (i<=0 || L->next==L) 
		return false;			//i错误或者L为空表返回假
	if (i==1)					//i=1作为特殊情况处理
	{
		e=L->next->data;
		return true;
	}
	else						//i不为1时
	{
		while (j<=i-1 && p!=L)	//查找第i个结点p
		{
			j++;
			p=p->next;
		}
		if (p==L)				//没有找到第i个节，返回假
			return false;
		else					//找到了第i个节，返回真
		{
			e=p->data;
			return true;
		}
	}
}

查找第一个值域为e的元素序号

int LocateElem(DlinkNode *L,ElemType e)	//查找第一个值域为e的元素序号
{
	int i=1;
	DlinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		i++;
		p=p->next;
	}
	if (p==NULL)			//不存在值为e的结点,返回0
		return(0);
	else					//存在值为e的结点,返回其逻辑序号i
		return(i);
}

插入第i个元素

bool ListInsert(DlinkNode *&L,int i,ElemType e)	//插入第i个元素
{
	int j=1;
	DlinkNode *p=L,*s;
	if (i<=0) return false;				//i错误返回假
	if (p->next==L)						//原双链表为空表时
	{	
		s=(DlinkNode *)malloc(sizeof(DlinkNode));	//创建新结点s
		s->data=e;
		p->next=s;s->next=p;
		p->prior=s;s->prior=p;
		return true;
	}
	else if (i==1)						//L不为空，i=1作为特殊情况处理
	{
		s=(DlinkNode *)malloc(sizeof(DlinkNode));	//创建新结点s
		s->data=e;
		s->next=p->next;p->next=s;		//将结点s插入到结点p之后
		s->next->prior=s;s->prior=p;
		return true;
	}
	else								//i不为1时
	{	
		p=L->next;
		while (j<=i-2 && p!=L)			//查找第i-1个结点p
		{	j++;
			p=p->next;
		}
		if (p==L)						//未找到第i-1个结点
			return false;
		else							//找到第i-1个结点*p
		{
			s=(DlinkNode *)malloc(sizeof(DlinkNode));	//创建新结点s
			s->data=e;	
			s->next=p->next;			//将结点s插入到结点p之后
			if (p->next!=NULL) p->next->prior=s;
			s->prior=p;
			p->next=s;
			return true;
		}
	}
}

删除第i个元素

bool ListDelete(DlinkNode *&L,int i,ElemType &e) //删除第i个元素
{
	int j=1;
	DlinkNode *p=L,*q;
	if (i<=0 || L->next==L) 
		return false;				//i错误或者为空表返回假
	if (i==1)						//i==1作为特殊情况处理
	{
		q=L->next;					//删除第1个结点
		e=q->data;
		L->next=q->next;
		q->next->prior=L;
		free(q);
		return true;
	}
	else							//i不为1时
	{	
		p=L->next;
		while (j<=i-2 && p!=NULL)	//查找到第i-1个结点p	
		{
			j++;
			p=p->next;
		}
		if (p==NULL)				//未找到第i-1个结点
			return false;
		else						//找到第i-1个结点p
		{
			q=p->next;				//q指向要删除的结点
			if (q==NULL) return 0;	//不存在第i个结点
			e=q->data;
			p->next=q->next;		//从单链表中删除q结点
			if (p->next!=NULL) p->next->prior=p;
			free(q);				//释放q结点
			return true;
		}
	}
}

最后是主函数

int main()
{
	DlinkNode *h;
	ElemType e;
	printf("循环双链表的基本运算如下:n");
	printf("  (1)初始化循环双链表hn");
	InitList(h);
	printf("  (2)依次采用尾插法插入a,b,c,d,e元素n");
	ListInsert(h,1,'a');
	ListInsert(h,2,'b');
	ListInsert(h,3,'c');
	ListInsert(h,4,'d');
	ListInsert(h,5,'e');
	printf("  (3)输出循环双链表h:");
	DispList(h);
	printf("  (4)循环双链表h长度:%dn",ListLength(h));
	printf("  (5)循环双链表h为%sn",(ListEmpty(h)?"空":"非空"));
	GetElem(h,3,e);
	printf("  (6)循环双链表h的第3个元素:%cn",e);
	printf("  (7)元素a的位置:%dn",LocateElem(h,'a'));
	printf("  (8)在第4个元素位置上插入f元素n");
	ListInsert(h,4,'f');
	printf("  (9)输出循环双链表h:");
	DispList(h);
	printf("  (10)删除h的第3个元素n");
    	ListDelete(h,3,e);
	printf("  (11)输出循环双链表h:");
	DispList(h);
	printf("  (12)释放循环双链表hn");
	DestroyList(h);
	return 1;
}

运行结果

有问题可以大家一起交流一下~
以下是完整工程，工程里99%的代码在上面都有。
链接：https://pan.baidu.com/s/1iT4tM8UDEho0TnblZJcDnQ
提取码：db4z