详解循环链表

Lemonflavoredgum

已于 2023-10-15 13:16:42 修改

阅读量101

点赞数

文章标签：链表数据结构

于 2023-10-15 12:58:06 首次发布

本文链接：https://blog.csdn.net/Lemonflavoredgum/article/details/133834880

版权

一:循环链表的定义

循环链表是一种特殊的链表，它的尾节点指向头节点，形成一个环形结构。与单向链表相比，循环链表可以更方便地实现在链表头部和尾部的插入和删除操作。

循环链表的节点包含两个部分：数据域和指针域。数据域存储节点的数据，指针域存储下一个节点的地址。在循环链表中，最后一个节点的指针域指向头节点，形成一个环。

二：循环链表的基本操作：

创建、插入节点、删除节点、遍历和销毁。其中，插入和删除节点的操作与单向链表类似，只需要注意处理头节点和尾节点的指针即可。

三：链表的操作

初始化

/*1. 初始化*/
int init(SingleLinkList **Head)
{
	if(1)
	{
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
			printf("申请内存错误， 初始化失败！[100001]\n");
			return 100001;
		}
		(*Head)->next = *Head;
		/*循环链表*/
		/*
			(*Head)->next = *Head;
		*/
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}

头插法

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}

尾插法

/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;
	SingleLinkNode *p;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}

	newNode->data = x;
	newNode->next = *Head;
	/*
	  循环链表
	  newNode->next = *Head;
	*/

	p = (*Head);

	while(p->next!=*Head)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}

i处差入元素

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
	int j;
	SingleLinkNode *p;
	SingleLinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	if(i<1 || i>length(*Head)+1)
	{
		printf("位置i不是链表有效位置！[100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;

	while(j<i)
	{
		j++;
		p = p->next;
	}

	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}

删除元素

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
	int i;
	int j;

	SingleLinkNode *p;
	SingleLinkNode *q; /*要删除的元素x*/

	i = find(*Head,x);
	if(!i)
	{
		printf("元素x【%d】不存在！100006\n", x);
		return 100006;
	}
	
	p = (*Head);
	j=1;

	while(j<i)
	{
		j++;
		p = p->next;
	}
	
	q = p->next;
	p->next = q->next;

	free(q); /*释放内存*/

	return 0;
}

链表长度

/*4. 链表长度*/
int length(SingleLinkList *Head)
{
	int len=0;
	SingleLinkNode *p;

	p = Head->next;
	while(p!=Head)	/* while(p!=Head) */
	{
		len++;
		p = p->next;
	}
	return len;
}

查找x值的元素

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
	int i;
	SingleLinkNode *p;

	i = 1;
	p = Head->next;

	while(p!=Head && p->data != x)  /*while( p!= Head && p->data != x) */
	{
		i++;
		p = p->next;
	}

	if(p==Head)  /* if(p->next == Head) */
	{
		return 0;
	}
	else
	{
		return i;
	}

}

输出链表

/*6.输出链表*/
void print(SingleLinkList *Head)
{
	SingleLinkNode *p;
	int i=0;

	p = Head->next;
	if(p==Head)				/*  if(p!=Head)  */
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)  /* while(p!=Head)  */
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

main

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.c"
#include "welcome.h"


int main(int argc, char* argv[])
{
	SingleLinkList *Head;
	DataType x;
	int i,m,n,cmd;

	for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<1000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}

	printf("-----------简单链表演示程序----------\n");
	do
	{
		printf("1. 初始化链表表\n");
		printf("2. 插入元素（头插法）\n");
		printf("3. 插入元素（尾插法）\n");
		printf("4. 插入元素（在位置i插入）\n");
		printf("5. 查找元素x\n");
		printf("6. 求链表长度\n");
		printf("7. 输出链表\n");
		printf("8. 删除元素\n");
		printf("10. 帮助\n"); 
		printf("0. 退出\n");
		printf("请输入您要进行的操作（1~6,0退出）：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			if(!init(&Head))
			{
				printf("链表已初始化！\n");
			}
			break;
		case 2:
			printf("请输入插入元素x：x=");
			scanf("%d",&x);
			if(!insert_head(&Head,x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 3:
			printf("请输入插入元素x：x=");
			scanf("%d",&x);
			if(!insert_tail(&Head,x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 4:
			printf("请输入插入元素位置：");
			scanf("%d", &i);
			printf("请输入要插入的元素：");
			scanf("%d", &x);
			if(!insert(&Head, i, x))
			{
				printf("已在位置（%d）插入元素（%d）！\n",i, x);
			}
			break;
		case 5:
			printf("请输入要查找的元素x：");
			scanf("%d", &x);
			if(i = find(Head,x))
			{
				printf("元素%d存在，在链表位置%d.\n", x, i);
			}
			else
			{
				printf("在链表中未找到元素x。\n");
			}
			break;
		case 6:
			printf("链表的长度为：%d\n", length(Head));
			break;
		case 7:
			print(Head);
			break;
		case 8:
			printf("请输入要删除的元素x：");
			scanf("%d", &x);
			if(!delete(&Head, x))
			{
				printf("元素x【%d】已删除!\n", x);
			}
			break;
		case 10:
			printf(" 本程序为链表的演示程序，由Love lemons设计开发，程序完成了环形链表功能！\n");
			break;
			
		}
	}while(cmd != 0);

	return 0;
}

四：Demo:

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.c"
#include "welcome.h"

int main(int argc, char* argv[])
{
   SingleLinkList *Head;
   DataType x;
   int i,m,n,cmd;

   for(i=0;i<strlen(welcome);i++)
   {
       printf("%c",welcome[i]);
       for(m=0;m<1000;m++)
           for(n=0;n<1000;n++)
           {
               ;
           }
   }

   printf("-----------简单链表演示程序----------\n");
   do
   {
       printf("1. 初始化链表表\n");
       printf("2. 插入元素（头插法）\n");
       printf("3. 插入元素（尾插法）\n");
       printf("4. 插入元素（在位置i插入）\n");
       printf("5. 查找元素x\n");
       printf("6. 求链表长度\n");
       printf("7. 输出链表\n");
       printf("8. 删除元素\n");
       printf("10. 帮助\n");
       printf("0. 退出\n");
       printf("请输入您要进行的操作（1~6,0退出）：");
       scanf("%d", &cmd);
       switch(cmd)
       {
       case 1:
           if(!init(&Head))
           {
               printf("链表已初始化！\n");
           }
           break;
       case 2:
           printf("请输入插入元素x：x=");
           scanf("%d",&x);
           if(!insert_head(&Head,x))
           {
               printf("元素（%d）已插入\n", x);
           }
           break;
       case 3:
           printf("请输入插入元素x：x=");
           scanf("%d",&x);
           if(!insert_tail(&Head,x))
           {
               printf("元素（%d）已插入\n", x);
           }
           break;
      case 4:
           printf("请输入插入元素位置：");
           scanf("%d", &i);
           printf("请输入要插入的元素：");
           scanf("%d", &x);
           if(!insert(&Head, i, x))
           {
               printf("已在位置（%d）插入元素（%d）！\n",i, x);
           }
           break;
       case 5:
           printf("请输入要查找的元素x：");
           scanf("%d", &x);
           if(i = find(Head,x))
           {
               printf("元素%d存在，在链表位置%d.\n", x, i);
           }
           else
           {
               printf("在链表中未找到元素x。\n");
           }
           break;
       case 6:
           printf("链表的长度为：%d\n", length(Head));
           break;
       case 7:
           print(Head);
           break;
       case 8:
           printf("请输入要删除的元素x：");
           scanf("%d", &x);
           if(!delete(&Head, x))
           {
               printf("元素x【%d】已删除!\n", x);
           }
           break;
       case 10:
           printf(" 本程序为链表的演示程序，由Love lemons设计开发，程序完成了环形链表功能！\n");
           break;

       }
   }while(cmd != 0);

return 0;
}

/*
SingleLinkList.c

*/
#include "SingleLinkList.h"
#include <stdlib.h>
#include <stdio.h>

/*1. 初始化*/
int init(SingleLinkList **Head)
{
   if(1)
   {
       /*申请内存*/
       (*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
       /*判断内存申请是否成功*/
       if(*Head == NULL)
       {
           printf("申请内存错误，初始化失败！[100001]\n");
           return 100001;
       }
       (*Head)->next = *Head;
       /*循环链表*/
       /*
           (*Head)->next = *Head;
       */
       return 0;
   }
   else
   {
       printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
       return 100002;
   }
}

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;

   if(0)
   {
       printf("链表未初始化！[100003]\n");
       return 100003;
   }

   newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
   if(!newNode)
   {
       printf("申请节点内存空间失败！[100004]\n");
       return 100004;
   }
   newNode->data = x;
   newNode->next = (*Head)->next;

(*Head)->next = newNode;

return 0;
}

/*2. 插入元素，尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
SingleLinkNode *p;

   newNode->data = x;
   newNode->next = *Head;
   /*
   循环链表
   newNode->next = *Head;
   */

p = (*Head);

   while(p->next!=*Head)
   {
       p = p->next;
   }

p->next = newNode;

return 0;
}

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
   int j;
   SingleLinkNode *p;
   SingleLinkNode *newNode;

   /*对i进行判断，0<i<=length+1*/
   if(i<1 || i>length(*Head)+1)
   {
       printf("位置i不是链表有效位置！[100005]\n");
       return 100005;
   }
   p = (*Head);
   j = 1;

   while(j<i)
   {
       j++;
       p = p->next;
   }

newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
/*此处省略检测newNode是否申请成功*/

   newNode->data = x;
   newNode->next = p->next;
   p->next = newNode;
   return 0;
}

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
int i;
int j;

SingleLinkNode *p;
SingleLinkNode *q; /*要删除的元素x*/

   i = find(*Head,x);
   if(!i)
   {
       printf("元素x【%d】不存在！100006\n", x);
       return 100006;
   }

   p = (*Head);
   j=1;

   while(j<i)
   {
       j++;
       p = p->next;
   }

   q = p->next;
   p->next = q->next;

free(q); /*释放内存*/

return 0;
}

/*4. 链表长度*/
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;

   p = Head->next;
   while(p!=Head)   /* while(p!=Head) */
   {
       len++;
       p = p->next;
   }
   return len;
}

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
int i;
SingleLinkNode *p;

i = 1;
p = Head->next;

   while(p!=Head && p->data != x) /*while( p!= Head && p->data != x) */
   {
       i++;
       p = p->next;
   }

   if(p==Head) /* if(p->next == Head) */
   {
       return 0;
   }
   else
   {
       return i;
   }

}

/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;

   p = Head->next;
   if(p==Head)               /* if(p!=Head) */
   {
       printf("链表为空！\n");
       return;
   }
   while(p!=Head) /* while(p!=Head) */
   {
       printf("Node[%d]. = %d\n", ++i, p->data);
       p = p->next;
   }
}

/*
SingleLinkList.h
*/

typedef int DataType;

/*简单链表的定义*/
typedef struct node
{
DataType data; /*数据域*/
struct node *next; /*指针域*/
}SingleLinkList, SingleLinkNode;

/*1. 初始化*/
int init(SingleLinkList **Head);

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x);

/*2. 插入元素，尾插法*/
int insert_tail(SingleLinkList **Head, DataType x);

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x);

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x);

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x);

/*6. 求链表的长度 */
int length(SingleLinkList *Head);

/*7.输出链表*/
void print(SingleLinkList *Head);

运行截图：

五：小结：

循环链表的优点是可以更方便地实现在链表头部和尾部的插入和删除操作，同时可以避免单向链表中的“死结点”问题。缺点是操作复杂度较高，需要额外处理尾节点的指针。

循环链表适用于需要在链表头部和尾部频繁进行插入和删除操作的场景，例如操作系统中进程的调度。

六：参考文献

1.数据结构c语言版（李刚）

2.百度

3.CSDN

七：一元多项式

一元多项式是指只含有一个变量的多项式。它的一般形式可以表示为：

P(x) = a_n * xn + a_{n-1} * x{n-1} + ... + a_1 * x + a_0

其中，P(x)表示多项式，x表示变量，a_n, a_{n-1}, ..., a_1, a_0表示多项式的系数，n表示多项式的次数。

一元多项式的基本操作包括：

初始化：创建一个空的多项式。
添加项：向多项式中添加一项，包括系数和指数。
删除项：从多项式中删除指定指数的项。
求值：给定变量的值，计算多项式的值。
加法：将两个多项式相加，得到一个新的多项式。
减法：将一个多项式减去另一个多项式，得到一个新的多项式。
乘法：将两个多项式相乘，得到一个新的多项式。
求导：对多项式进行求导操作，得到一个新的多项式。
输出：按照一定格式输出多项式。

一元多项式在数学、计算机科学和工程等领域中广泛应用，例如代数运算、信号处理、图像处理等。在实际应用中，常常使用数组或链表等数据结构来表示和操作一元多项式。

Demo:

#include<stdio.h>
//一元多项式定义
typedef struct node{
float coef; //系数
int expn; //指数
struct node *next; //后继
}pnode,*polynomial;

//一元多项式创建
polynomial createpolyn(polynomial p,int m){
int i;
polynomial q,pre,s; //结点q,pre,s
p = (polynomial)malloc(sizeof(pnode)); //生成新结点
p->next = 0;//建立一个带头结点的单链表
p->expn = -1;//头结点指数值设为1
for ( i = 0; i < m; i++)//依次输入m个非零值
{
s = (polynomial)malloc(sizeof(pnode));//生成新结点
printf("输入系数和指数");
scanf("%f%d",&s->coef,&s->expn);//输入系数和指数
pre = p;//pre用于保存q的前驱
q = p->next;
while (q&&q->expn<=s->expn)
{//找到第一个大于输入项指数的项q
pre = q;
q = q->next;
}
s->next = q;//将输入项s，插入到q和pre之间
pre->next = s;

}
printf("--创建成功--\n");
return p;
}

//一元多项式打印
void pri (polynomial p){
polynomial q;
int id = 1;
q = p->next;//首结点
printf("加法运算后结果为：\n");
while (q)
{
printf("第%d个结点:系数%f,指数%d\n",id,q->coef,q->expn);
q = q->next;//结点后移
id++;
}

}

//一元多项式相加
polynomial addpolyn(polynomial pa,polynomial pb){
polynomial p1,p2,p3,q;
int sum;//系数和
p1 = pa->next;
p2 = pb->next;
p3 = pa;//p3指向和多项式的当前结点
while (p1&&p2)
{//p1和p2均非空
if (p1->expn==p2->expn)//指数相同
{
sum = p1->coef+p2->coef;//sum保存两项的系数和
if (sum)//系数和部位0
{
p1->coef = sum;//修改结点p1的系数值
p3->next = p1;
p3 = p1;//将修改和的结点p1链在p3之后
p1 = p1->next;//p1指向后一项
q = p2;
p2 = p2->next;
free(q);//删除pb当前节点q
}else{//系数和为0
q = p1;
p1 = p1->next;
free(q);//删除pa当前节点p1
q = p2;
p2 = p2->next;
free(q);//删除pb当前节点p2
}

}else{
if (p1->expn<=p2->expn)//pa当前结点p1的指数值小
{
p3->next = p1;//将p1链接在p3之后
p3 = p1;//p3指向p1
p1 = p1->next;//p1指向后一项
}else{
p3->next = p2;//pb当前结点p2的指数值小
p3 = p2;//将p2链接在p3之后
p2 = p2->next;//p2指向后一项
}

}

}
p3->next = p1?p1:p2;//插入非空多项式的剩余段
free(pb);//释放pb的头结点
return pa;//返回和多项式
}

main(){
int m;
polynomial pa,pb,pc;//声明一元多项式pa,pb,pc
printf("==========创建一元多项式==========\n");
printf("创建A项数");scanf("%d",&m);//创建pa项数
pa = createpolyn(pa,m);//创建一元多项式pa
printf("创建B项数");scanf("%d",&m);//创建pb项数
pb = createpolyn(pb,m);//创建一元多项式pb
printf("==========一元多项式相加==========\n");
pc = addpolyn(pa,pb);//一元多项式相加
pri(pc);//打印一元多项式pc
printf("==========END==========");
}

运行截图：