循环链表-数据结构（C语言）

不想写代码小猿

已于 2023-10-15 21:46:28 修改

阅读量238

点赞数

文章标签：数据结构链表 c语言

于 2023-10-14 20:29:05 首次发布

本文链接：https://blog.csdn.net/2301_79870182/article/details/133826697

版权

前言

在将循环链表之前我们第一步要掌握的是链表，循环链表是链表的一种。

循环列表

定义

循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

结构

循环链表的循环方式是其尾结点的后继指针指向头结点(表头)，而头结点的前置指针指向尾结点，达到循环的目的，这样不仅使得对链表尾部的操作更为简单，也减少了对NULL指针的引用

特点

1.是链表的扩展，通过将最后一个节点的指针指向第一个节点，形成了一个环状结构。

2.提供了正向和反向两种遍历方式。

3.缺点是在插入和删除数据时，需要考虑调整指针方向，操作比单链表复杂

一.循环链表操作

1.循环链表头文件及函数声明

1.使用#incliude<stdiib.h>开辟文件空间

/*定义数据节点*/
typedef struct Node{
	int data;
	struct Node* pre;
	struct Node* next;
}Node;

//初始化链表
int init(SingleLinkList **Head)

//1.头插法
int insert_head(SingleLinkList **Head, DataType x)

//2.尾插法
int insert_tail(SingleLinkList **Head, DataType x)

//3.按位置插入
int insert(SingleLinkList **Head, int i, DataType x)

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

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

//4. 链表长度
int length(SingleLinkList *Head)

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

2.初始化

在对使用链表进行数据的储存之前，我们需要进行链表的初始化

循环链表的初始化需要创建一个节点结构体，包含数据域和指针域。然后创建一个循环链表结构体，包含头节点、尾节点和链表长度等属性，以及添加节点、删除节点等方法。

循环链表的节点由三部分组成：

1.定义数据

2.定义指针1：指向后继节点的指针

3.定义指针2：指向前置节点的指针

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

3.插入操作

插入操作：断开原先的联系，将新的元素插入

插入包括：头插法，尾插法，安位置插入

1.头插法

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)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}

3.按位置插入

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;
}

4.删除操作

双向循环链表的删除大致与单链表相同，被删除结点的前置结点的后继指针指向被删除结点的后继结点，而后继结点的前置指针指向前置结点

代码如下

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;
}

5.查找元素，并返回值

在数据中找出自己想要的值，并且返回输出，情况分为俩种：找出和找出未。找出方法思路：遍历一遍找出值，找出输出值，为找出输出0

代码如下：

int find(SingleLinkList *Head, DataType x)
{
	int i;
	SingleLinkNode *p;

	i = 1;
	p = Head->next;

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

	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) 			
	{
		printf("链表为空！\n");
		return;
	}
	 while(p!=Head) 
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

二：运行结果

经过以上的讲解个个循环结构的代码操作接下来是个个操作的结果

1.初始化

2.插入法

1.头插法

2.尾插法

3.按位置插入

3删除操作

4查询元素返回值

6.输出链表

这里重新初始化直接输出链表

三.完整代码

1.main.c

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.h"
#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("请输入插入元素位置i和元素x（i，x）：");
			scanf("%d,%d", &i, &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(" 本程序为链表的演示程序，有XXX设计开发，程序完成了。。。。功能！。。。\n");
			break;
			
		}
	}while(cmd != 0);

	return 0;
}

2.结构函数

/*
	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(SingleLinkL

3.操作函数

/*
	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;

	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)
	{
		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;
}


/*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->next == Head)  /* if(p->next == Head) */
	{
		return 0;
	}
	else
	{
		return i;
	}

}

/*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;
}

/*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;
	}
}

四.总结

经以上为双向循环链表的实现和方法讲解总结：

1.了解和实际操作循环链表：循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

2.对链表有更深的了解;

五.参考文献

1.csdn社区

2.老师代码