数据结构（c语言版）-----单向循环链表的基本操作（初始化、插入、删除、修改、遍历等操作）

最新推荐文章于 2022-03-21 21:42:58 发布
最新推荐文章于 2022-03-21 21:42:58 发布
阅读量9.2k 收藏 285
点赞数 40
文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43870670/article/details/104830273
版权

单向循环链表基本操作

单向循环链表是头节点和尾结点重合，但无论在插入、查找、删除等都是在同一方向上。

文章目录

创建链表的两种方法

头插法

bool InitList(Node *l) {
	if (l==NULL)
	{
		return false;//判断申请的内存是否成功
	}
	printf("请输入链表的长度：");
	int len;
	scanf("%d", &len);
	l->next = l;//使头结点与尾结点重合
	l->data = len;
	Node *p;
	srand((int)time(0));
	for (int i = 0; i < len; i++)
	{
		//头插法
		p = (Node *)malloc(sizeof(Node));
		p->data = rand() % 100;
		p->next = l->next;
		l->next = p;
	}
	return true;
}

尾插法

bool InitList(Node *l) {
	if (l == NULL)
	{
		return false;//判断申请的内存是否成功
	}
	printf("请输入链表的长度：");
	int len;
	scanf("%d", &len);
	l->next = l;//使头结点与尾结点重合
	l->data = len;
	Node *p, *q;
	q = l;
	srand((int)time(0));
	for (int i = 0; i < len; i++)
	{
		//尾插法
		p = (Node *)malloc(sizeof(Node));
		p->data = rand() % 100;
		q->next = p;
		q = p;
	}
	q->next = l;//最后还是将当前节点与头指针相连
	return true;
}

获取单向循环链表的长度

int LengthList(Node *l) {
	Node *p = l->next;
	int i = 0;//长度计数器
	while (p!=l)
	{
		//根据指针是否到达头结点或尾结点来判断程序是否结束
		i++;
		p = p->next;
	}
	return i;
}

在指定位置后插入元素

bool InsertByIndex(Node *l, int i, int data) {
	Node *p = l->next;
	int j = 0;
	while (p!=l&&j<i-1)
	{
		//利用循环找到待插入位置的前驱
		j++;
		p = p->next;
	}
	if (p==l||j>i-1)
	{
		return false;//判断下标是否合法
	}
	Node *q = (Node *)malloc(sizeof(Node));
	
	q->data = data;
	q->next = p->next;
	p->next = q;
	return true;

}

根据下标删除元素

bool DeleteByIndex(Node *l, int i) {
	Node *p = l->next;
	int j = 1;
	while (p != l && j < i - 1)
	{
		j++; //利用循环找到待删除位置的前驱
		p = p->next;
	}
	if (p == l || j > i - 1)
	{
		return false;//判断下标是否合法
	}
	Node *q = (Node *)malloc(sizeof(Node));

	
	q = p->next;//将待删除节点的前驱和待删除节点的后继相连
	p->next = q->next;
	free(q);//释放内存
	return true;

}

根据元素的值删除元素

bool DeleteByIndex(Node *l, int i) {
	Node *p = l->next;
	int j = 1;
	while (p != l && j < i - 1)
	{
		j++; //利用循环找到待删除位置的前驱
		p = p->next;
	}
	if (p == l || j > i - 1)
	{
		return false;//判断下标是否合法
	}
	Node *q = (Node *)malloc(sizeof(Node));

	
	q = p->next;//将待删除节点的前驱和待删除节点的后继相连
	p->next = q->next;
	free(q);//释放内存
	return true;

}
bool DeleteByData(Node *l, int data) {
	int i = 1;
	Node *p = l->next;
	while (p!=l)
	{
	//利用循环找到待删除节点的下标
		if (p->data == data)
			if (DeleteByIndex(l,i))
			{//再根据下标删除指定值
				return true;
			}
		i++;
		p = p->next;
	}
	return false;
}

根据下标寻找元素

int SearchByIndex(Node *l, int i) {
	Node *p = l->next;
	int j = 1;
	while (p!=l&&j<i-1)
	{//利用循环找到待查找位置的前驱
		j++;
		p = p->next;
	}
	if (p==l||j>i-1)
	{
		return -1;//判断下标是否合法
	}
	return p->next->data;
}

根据值获取元素的下标

int SearchByData(Node *l, int data) {
	Node *p = l->next;
	int j = 0;
	while (p != l )
	{//利用循环找到待查找值的下标
		j++;
		if (p->data==data)
		{
			return j;
		}
		p = p->next;
	}
	return -1;
}

根据下标修改元素的值

bool UpdateByIndex(Node *l, int i, int data) {
	Node *p = l->next;
	int j = 1;
	while (p != l && j < i - 1)
	{//利用循环找到待修改节点的前驱
		j++;
		p = p->next;
	}
	if (p == l || j > i - 1)
	{
		return false;//判断下标是否合法
	}
	p->next->data = data;
	return true;
}

遍历链表

void printfList(Node *l) {
	Node *p = l->next;
	while (p != l) {
		//将当前指针是否等于头节点作为循环是否终止的条件
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

清空链表

bool ClearList(Node *l) {
	if (l->next ==l)
	{
		return false;//判断链表是否为空
	}
	Node *p = l->next;
	Node *q;
	while (p != l)
	{
		//逐一删除节点
		q = p->next;
		free(p);
		p = q;
	}
	//最后将头节点指向尾结点
	l->next = l;
	return true;
}

整体代码展示

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<time.h>
typedef struct node {
	int data;
	struct node *next;
}Node;
bool InitList(Node *l);//单向循环链表的初始化
int LengthList(Node *l);//获取单向循环链表的长度
bool InsertByIndex(Node *l, int i, int data);//在指定下标后插入元素
bool DeleteByIndex(Node *l, int i);//根据下标删除当前元素
bool DeleteByData(Node *l, int data);//根据当前值删除当前元素
int SearchByIndex(Node *l, int i);//根据下标查找元素的值
int SearchByData(Node *l, int data);//根据值获取元素的下标
bool UpdateByIndex(Node *l, int i, int data);//修改指定位置的元素
void printfList(Node *l);//遍历单向循环链表
bool ClearList(Node *l);//清空单向循环链表
int main() {
	bool flag = true;
	int choice;
	Node *l = (Node *)malloc(sizeof(Node));
	int i;
	int data;
	while (flag)
	{
		printf("\n=====单向循环链表的基本操作=====\n");
		printf("1.单向循环链表的初始化\n");
		printf("2.获取单向循环链表的长度\n");
		printf("3.单向循环链表的插入（在指定位置后插入）\n");
		printf("4.单向循环链表的删除（根据下标）\n");
		printf("5.单向循环链表的删除（根据给定的值）\n");
		printf("6.根据指定下标查找指定元素\n");
		printf("7.根据给定的值查找元素的下标\n");
		printf("8.根据元素的下标修改元素的值\n");
		printf("9.打印单向循环链表\n");
		printf("10.清空单向循环链表\n");
		printf("==退出输入0==================\n");
		printf("请输入你的选择：");
		scanf("%d", &choice);
		switch (choice)
		{
		case 1:
			if (InitList(l))
			{
				printf("\n创建成功！\n");
			}
			else {
				printf("\n创建失败\n");
			}
			break;
		case 2:
			printf("\n链表的长度为：%d\n", LengthList(l));
			break;
		case 3:
			printf("i,data = ");
			scanf("%d", &i);
			scanf("%d", &data);
			if (InsertByIndex(l, i, data))
			{
				printf("\n插入成功！\n");
			}
			else {
				printf("\n插入失败！\n");
			}
			break;
		case 4:
			printf("i = ");
			scanf("%d", &i);
			if (DeleteByIndex(l, i))
			{
				printf("\n删除成功\n");
			}
			else {
				printf("\n删除失败\n");
			}
			break;
		case 5:
			printf("data = ");
			scanf("%d", &data);
			if (DeleteByData(l, data))
			{
				printf("\n删除成功\n");
			}
			else {
				printf("\n删除失败\n");
			}
			break;
		case 6:
			printf("i = ");
			scanf("%d", &i);
			if (SearchByIndex(l, i)!=-1)
			{
				printf("\n%d 位置上的数值为：%d\n", i, SearchByIndex(l, i));
			}
			else {
				printf("\n下标不合法\n");
			}
			break;
		case 7:
			printf("data = ");
			scanf("%d", &data);
			if (SearchByData(l, data)!=-1)
			{
				printf("\n%d 的下标为：%d\n", data, SearchByData(l, data));
			}
			else {
				printf("\n没有找到该数据\n");
			}
			break;
		case 8:
			printf("i,data = ");
			scanf("%d", &i);
			scanf("%d", &data);
			if (UpdateByIndex(l, i, data))
			{
				printf("\n修改成功\n");
			}
			else {
				printf("\n下标不合法\n");
			}
			break;
		case 9:
			printfList(l);
			break;
		case 10:
			if (ClearList(l))
			{
				printf("\n全部清空\n");
			}
			else {
				printf("\n此表已为空\n");
			}
			break;
		default:
			flag = false;
			break;
		}

	}
	printf("\n=======程序结束=======\n");
}
bool InitList(Node *l) {
	if (l==NULL)
	{
		return false;//判断申请的内存是否成功
	}
	printf("请输入链表的长度：");
	int len;
	scanf("%d", &len);
	l->next = l;//使头结点与尾结点重合
	l->data = len;
	Node *p;
	srand((int)time(0));
	for (int i = 0; i < len; i++)
	{
		//头插法
		p = (Node *)malloc(sizeof(Node));
		p->data = rand() % 100;
		p->next = l->next;
		l->next = p;
	}
	return true;
}

int LengthList(Node *l) {
	Node *p = l->next;
	int i = 0;//长度计数器
	while (p!=l)
	{
		//根据指针是否到达头结点或尾结点来判断程序是否结束
		i++;
		p = p->next;
	}
	return i;
}
bool InsertByIndex(Node *l, int i, int data) {
	Node *p = l->next;
	int j = 0;
	while (p!=l&&j<i-1)
	{
		//利用循环找到待插入位置的前驱
		j++;
		p = p->next;
	}
	if (p==l||j>i-1)
	{
		return false;//判断下标是否合法
	}
	Node *q = (Node *)malloc(sizeof(Node));
	
	q->data = data;
	q->next = p->next;
	p->next = q;
	return true;

}
bool DeleteByIndex(Node *l, int i) {
	Node *p = l->next;
	int j = 1;
	while (p != l && j < i - 1)
	{
		j++; //利用循环找到待删除位置的前驱
		p = p->next;
	}
	if (p == l || j > i - 1)
	{
		return false;//判断下标是否合法
	}
	Node *q = (Node *)malloc(sizeof(Node));

	
	q = p->next;//将待删除节点的前驱和待删除节点的后继相连
	p->next = q->next;
	free(q);//释放内存
	return true;

}
bool DeleteByData(Node *l, int data) {
	int i = 1;
	Node *p = l->next;
	while (p!=l)
	{
	//利用循环找到待删除节点的下标
		if (p->data == data)
			if (DeleteByIndex(l,i))
			{//再根据下标删除指定值
				return true;
			}
		i++;
		p = p->next;
	}
	return false;
}
int SearchByIndex(Node *l, int i) {
	Node *p = l->next;
	int j = 1;
	while (p!=l&&j<i-1)
	{//利用循环找到待查找位置的前驱
		j++;
		p = p->next;
	}
	if (p==l||j>i-1)
	{
		return -1;//判断下标是否合法
	}
	return p->next->data;
}
int SearchByData(Node *l, int data) {
	Node *p = l->next;
	int j = 0;
	while (p != l )
	{//利用循环找到待查找值的下标
		j++;
		if (p->data==data)
		{
			return j;
		}
		p = p->next;
	}
	return -1;
}
bool UpdateByIndex(Node *l, int i, int data) {
	Node *p = l->next;
	int j = 1;
	while (p != l && j < i - 1)
	{//利用循环找到待修改节点的前驱
		j++;
		p = p->next;
	}
	if (p == l || j > i - 1)
	{
		return false;//判断下标是否合法
	}
	p->next->data = data;
	return true;
}
void printfList(Node *l) {
	Node *p = l->next;
	while (p != l) {
		//将当前指针是否等于头节点作为循环是否终止的条件
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
bool ClearList(Node *l) {
	if (l->next ==l)
	{
		return false;//判断链表是否为空
	}
	Node *p = l->next;
	Node *q;
	while (p != l)
	{
		//逐一删除节点
		q = p->next;
		free(p);
		p = q;
	}
	//最后将头节点指向尾结点
	l->next = l;
	return true;
}

公众号推荐

如果感觉我的分享对你有帮助，麻烦支持一下公众号，更多实用的内容也将同步更新到公众号。

在这里插入图片描述

何一平？
关注
  • 40
    点赞
  • 踩
  • 285
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
单向循环链表的基本操作
MOON5555的博客
10-23 470
单向循环链表的基本操作 1、头文件（clist.h） #pragma once //循环链表 typedef struct CNode { int data; struct CNode *next; }CNode,*CList; //循环链表初始化 void InitList(CList plist); //头插 bool Insert_head(CList plist,
循环单链表的基本操作
罗小黑の窝
04-30 764
循环单链表所尊崇的结点如图 所实现的功能如下： void InitList(List *list);//初始化 bool push_back(List *list, ElemType x);//尾插 bool push_front(List *list, ElemType x);//头插 bool pop_back(List *list);//尾删 bool pop_front
单向链表，单向循环链表的基本操作
架构设计
04-21 168
链表可以解决数组对存储空间要求的问题，可以充分的利用存储空间，可以根据实际使用的需要来使用内存，链表的插入节点和删除节点都数组要简单，因为只要用指针加以处理就行了 ，但是在数组的查找上，数组的速度比链表快，因为从数组的索引就可以找到想要的数据，而链表需要花费很多时间去比较每一个节点，才能找到自己想要数据。 单向链表的每一个节点的数据结构都可以分为两个域，一个数据域，一个是指针域，因此可以...
数据结构_线性表_链式存储_单向循环链表的基本操作
iteye_14589的博客
05-06 164
1.概述： 对于一个循环链表来说,其首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。要转换一个循环链表，可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。再来看另一种方法，循环链表可以被视为“无头无尾”。这种列表很利于节约数据存储缓存， 假定你在一个列表中有一个对象并且希望所有其他对象迭代在一个非特殊的排列下。 指向整个列表的指针可以被称作访问指针。 用...
单向循环链表基本操作
icquu的博客
10-14 485
C和其他语言都一样，只是关键字更少，更接近硬件，底层操作大都需要用C中的头文件和库函数来实现。学习的过程也不乏乐趣，在入门阶段，不建议大家去磨练算法，非常枯燥。建议学习一些系统编程和网络编程，趣味性更强，也能做一些有用的东西，不会乏味到失去兴趣。等过了这个阶段，对C的认识已经比较全面和具有一定深度了，再去看一些算法相关的，也不会觉得很复杂了。后期，不管用什么语言都完全是个人思维的表达，不影响表达思...
循环单链表的初始化，建立，插入，查找，删除。
weixin_30478923的博客
10-10 320
//////////////////////////////////////////////// //循环单链表的初始化，建立，插入，查找，删除。// //Author:Wang Yong // //Date: 2010.8.20 // //////////////////////////////////////////////// #...
个人C语言学习实录练习题-链表.数据结构.快速排序练习.rar
最新发布
05-22
通过本压缩包中的练习题，学习者可以实践C语言中的链表操作，比如创建链表、插入、删除、排序等，同时也能加深对快速排序算法的理解。在完成这些练习后，应当能够独立编写和调试涉及这些概念的代码，从而提升编程...
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
LinkedList类通常包含头节点和一些基本操作，如插入、删除、遍历等。在`list-2.py`文件中，我们可能会看到以下结构： ```python class Node: def __init__(self, data=None): self.data = data self.next = None...
数据结构与算法-顺序表（链表篇）
09-09
1. 单向链表的创建：如何初始化链表，以及如何创建新节点并将其插入到链表中。 2. 遍历链表：如何从头节点开始，按顺序访问每个节点，直到到达尾节点。 3. 插入操作：在链表的特定位置或头部、尾部插入新节点的代码...
实用单向链表的基本操作函数24个C语言版
03-23
以上就是这24个单向链表操作函数所涵盖的主要概念和用途，它们涵盖了链表操作的基础和一些高级特性，对于学习和理解链表数据结构以及C语言编程非常有帮助。这些操作不仅在理论学习中重要，在实际项目开发中也经常被...
第11章 动态数据结构-链表-21
08-03
在本章中，我们探讨了如何使用C语言实现动态数据结构——单向链表。单向链表是一种线性数据结构，其中每个节点包含数据以及指向下一个节点的指针。以下是一些关于单向链表的关键知识点： 1. **节点定义**：在C语言...
链表（3）----循环单链表基本操作
录事参军
12-09 1366
1、循环链表基本定义 typedef  struct CListElement_t_{     void *data;     struct CListElement_t *next; } CListElement_t typedef struct CList_t_ {     int size;     int (*match)(const void *key1,
循环链表的基本操作
BlaHole
03-18 1294
#include &lt;iostream&gt; #include &lt;stdlib.h&gt; #include &lt;Windows.h&gt; #include &lt;time.h&gt; using namespace std; typedef int dataType; typedef struct Node{ dataType data; struct Node ...
c语言实现单向循环链表的插入,C语言实现双向非循环链表的节点插入
weixin_42387319的博客
05-22 184
我在之前一篇博客中《C语言实现双向非循环链表的逆序打印》讲到了如何逆序输出一个双向非循环链表，让我们对这种链表类型有了理性的认识。今天我们要来实现的是对双向非循环链表进行节点的插入。大家可以和《C语言实现单链表节点的插入》单链表的节点插入对比着学习。代码上传至 https://github.com/chenyufeng1991/InsertDoubleLinkedList 。核心代码如下：Nod...
数据结构-单向循环链表（初始化、插入结点、删除结点等操作）
Eddy的博客
07-24 6394
单向循环链表 单向循环链表：将单向链表的最后一个结点指向头结点形成一个环，即成为单向循环链表，可以通过其中任意一个结点出发访问到其他结点。单向循环链表的操作方法与单向链表相似，只是在于循环条件存在差异。 特点： 若链表为空，则头结点的next结点还是指向其本身，即head ->next=head； 尾节点的next指针指向head结点，即头尾相连； 通过判断当前结点的next结点是否与head结点相等，即可判断是否对单向循环链表遍历完成； 循环链表无须增加存储量，仅对单向链表的链接方式稍作改变，即
c++实现单循环链表的初始化，创建，增加和删除操作
qq_44603585的博客
02-03 944
//单循环链表的初始化，创建，增加和删除操作 #include<iostream> #include<stdlib.h> #include<stdio.h> using namespace std; #define OK 1; #define ERROR 0; typedef int Status; typedef int ElemType; type...
数据结构-单向链表（初始化、插入、删除等基本操作）
Eddy的博客
07-23 785
单向链表 单向链表（又名单链表、线性链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过从头部开始，依序往下读取。 单向链表存在头节点，且头节点不保存数据 宏定义及函数声明 //定义处理的数据类型 typedef int ElemType; #define bool int //定义状态 typedef enum Status { success, fail, fatal, rang_err }Status; //定义数据类型的结构 typedef struct Nod
数据结构-单向循环链表（初始化、插入结点，头插，尾插，任意插入、删除结点等操作）
qq_44765615的博客
04-16 1982
数据结构-单向循环链表（初始化、插入结点、删除结点等操作） 单向循环链表 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 注： 我这个代码头节点即为首节点 通过判断当前结点的next结点是否与head结点相等，即可判断是否对单向循环链表遍历完成； #include <stdio.h> #include <stdlib.h> ///// 表示是一个节点 typedef struct Node
【数据结构算法】②、单向循环链表的创建插入删除实现、单向循环链表的初始化、遍历、插入(首元结点、其他结点情况)、删除元素、查询元素
慢慢来就很快。
03-21 2390
【数据结构算法】②、单向循环链表的创建插入删除实现、单向循环链表的初始化、遍历、插入(首元结点、其他结点情况)、删除元素、查询元素

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

何一平？

你的收获就是我学习的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值