2.4 循环单链表：理论+C语言详细实现

于 2022-07-29 14:43:07 发布
阅读量402 收藏 5
点赞数 1
分类专栏： 数据结构与算法 文章标签： c语言 链表 数据结构 循环单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986997/article/details/126055337
版权

1、顺序存储：线性表/栈/队列：理论+C语言实现–详细

2.1 链式存储概述 和 2.2 线性表的链式存储–单链表（C语言详细实现）

2.3带头结点的单链表：理论+编程实战（C语言详细）

文章目录

2.4 循环单链表

1 、循环单链表基本概念

单链表和带头结点的单链表不足之处：

  • 从表中的某个结点开始，都只能访问这个结点及其后面的结点，不能访问到它前面的结点，除非再从首指针所指向的结点开始访问。

循环链表优点

  • 可以解决单链表和带头结点的单链表不足之处。循环链表可以从表中的任意一个结点开始，都能访问表中的所有其他结点，只需要设置表中最后一个结点的指针域指向表中的第一个结点。

循环链表的实现：

单链表中某个结点p是表中最后一个结点的特征是p->nextNULL,对于一个循环单链表，若首指针为head，表中的某个结点p是最后一个结点的特征应该是p->nexthead.

在这里插入图片描述

2、ADT描述

数据集合 K：K={k1,k2,k3…,kn},n≥0，K中的元素是datatype类型；

数据关系R：R={r} ， r = {<Ki,Ki+1>|i=1,2,…，n-1};

操作集合如下：

函数功能
node *init()建立一个空的循环链表
void display(node *head, int i)输出带头结点的单链表中各个结点的值
node *findth(node *head, int i)按序号查找，在带头结点的单链表中查找第i个结点
node* find(node* head, datatype x)按值查找，在带头结点的链表中查找值为x的结点
node *insert(node *head , datatype x)在带头结点的单链表中插入一个值为x的结点
node *dele(node *head, datatype x)在带头结点的单链表中删除一个值为x的结点
int length(node *head)查询带头结点的链表的长度
node *rear(node *head)获得循环单链表的最后一个结点的存储地址

3、重要操作

  1. 插入（在第i-1(1<= i <=n+1 )）个结点后插入一个值为x的新结点
    • 1 先构造一个新结点，用s指向
    • 2 在找到链表的第i-1个结点，用p指向
    • 3 然后修改指针，插入结点（p之后插入新结点是s）

注意：如果插入的结点成为表中的第一个结点，那么必须修改表中最后一个结点的指针域，使最后一个结点的指针域指向新插入的结点。

在这里插入图片描述

  1. 删除（删除循环链表的第i(1<=i<=n)）个位置上的结点
    • 1 先找到链表的第i-1个结点，用p指向
    • 2 再用指针s指向要删除的结点（p的下一个结点）
    • 3 然后修改指针，删除s所指结点
    • 最后释放s所指结点的空间，这样内存空间才不会泄漏

注意：如果删除的结点是表中的第一个结点，那么必须要修改表中最后一个结点的指针域，使最后一个结点的指针域指向表中的第二个结点，而且首指针也指向原来表中第二个结点。

在这里插入图片描述

3、编程实战
  1. main.c
#include"clnklist.h"

void main()
{
	struct  clnkllist* head;
	node* p;
	head = init();
	int i = 0, number,position;
	while (i<5)//首先在空链表中插入0~4
	{
		head = insert(head, i, i);
		i++;
	}
	while (i<10)
	{
		printf("input the command that you want: 1:init	2:display		3:findth	 4:find		5:insert   6: dele    7:length  8:rear \n");
		scanf_s("%d", &i);

		switch (i)
	{
	case 1:free(head); head = init(); break;
	case 2:display(head); break;
	case 3: {
		printf("请输入要查找的结点的序号\n");
		scanf_s("%d", &position);
		p = findth(head, position);
		printf("info: %5d  next:%5d", p->info, p->next);
		break;
	}
	case 4: {
		printf("请输入要查找的结点的值\n");
		scanf_s("%d", &number);
		position = find(head, number);
		printf("值为%d的结点位置是：%5d\n", number,position);
		break;
	}
	case 5: {
		printf("please input the datatype and position that you want：\n");
		scanf_s("%d %d", &number, &position);
		head = insert(head,number, position);
		break;
	}
	case 6: {
		printf("input delete datatype ：\n");
		scanf_s("%d", &number);
		head=dele(head,number);
		break;
	}
	case 7:printf("The Linklist length is :%5d\n", length(head)); break;
	default:printf("input is error,input again\n"); break;
	}
  }
}
  1. 头文件：clnklist.h
#pragma once
#ifndef  __CLNKLIST_H
#define __CLNKLIST_H
#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct  clnkllist {
	datatype info;
	struct  clnklist* next;
}node;

//初始化一个空的循环链表
node* init();

//获得循环单链表的最后一个结点的存储地址
node* rear(node* head);

//打印输出循环链表中各个结点的值
void display(node* head);

//按序号查找，返回指向结点i的指针
node* findth(node* head, int i);

//按值查找，返回x结点的位置
int find(node* head, datatype x);

//插入一个新结点，返回头指针
node* insert(node* head, datatype x, int i);

//在循环链表中删除一个值为x的结点
node* dele(node* head, datatype x);

//查询链表的长度
int length(node* head);
#endif
  1. 函数定义：clnklist.c
#include"clnklist.h"
/*
*建立一个空的循环链表
*/
node* init()
{
	return NULL;  //创建成功返回null
}

/*
* 获得循环单链表的最后一个结点的存储地址
*/
node* rear(node  *head)
{
	node* p;
	if (!head)
	{
		p = NULL;
	}
	else
	{
		p = head;
		while (p->next!=head)
		{
			p = p->next;
		}
	}
	return p;  //返回指向尾结点的指针
}

/*
* 输出带头结点的单链表中各个结点的值
*/
void display(node* head)
{
	node* p;
	p = head;
	if (!p)
	{
		printf("circular single linked list is null\n");
	}
	else
	{
		printf("从头到尾，循环链表中各个值为\n");
		while (p!=rear(head))  //循环输出p的下一个结点是头结点
		{
			printf("%5d",p->info);
			p = p->next;
		}
		printf("%5d", p->info);
		printf("\n");
	}
}

//按序号查找，在带头结点的单链表中查找第i个结点
node* findth(node* head, int i)
{
	node* p;
	p = head;
	int sum = 0;
	if (!p||i<0)
	{
		printf("circular single linked list is null or input is <0\n");
		exit(1);
	}
	else
	{
		while (p->next != head&&sum<i)  //循环输出p的下一个结点是头结点
		{
			printf("%5d", p->info);
			p = p->next;
			sum++;
		}
		printf("查找到了%d个结点\n",i);
	}
	return p;
}

//按值查找，返回x所对应结点的位置
int find(node* head,datatype x)
{
	node* p = head;  //p指向头结点
	int sum = 0;
	if (!p )
	{
		printf("circular single linked list is null \n");
		return NULL;
	}
	else
	{
		while (p->next != head && p->info!= x)  //没有找到并且没有查找完整个表
		{
			p = p->next;
			sum++;
		}
		if (p->info==x)
		{
			printf("查找到了值为%d个结点\n", x);
			return sum;  //如果找到返回位置对应的序号
		}
		return 0;  //如果没有找到返回0
	}
}

/*
功能：指定链表位置pos插入一个值为x的结点
返回：链表头结点的指针
*/
node* insert(node* head, datatype x, int i)
{
	node* p, * q, * myrear;
	p = (node*)malloc(sizeof(node)); //为要插入的结点开辟一个结点空间
	p->info = x;
	if (i<0)
	{
		printf("插入的位置不能小于0，请重新输入\n");
		free(p);
		return head;
	}
	if (i==0&&!head)  //如果插入的位置是空链表的第一个结点,则新结点的指针域应指向它自己
	{
		p->next = p;    
		head = p;
		printf("%5d插入成功\n",x);

		return head;
	}
	if (i==0&&head)//如果在非空的链表最前面插入
	{
		myrear = rear(head); //找到喜欢链表的最后一个结点
		p->next = head;
		myrear->next = p;
		//head->next = p;
		printf("%5d插入成功\n", x);
		return head;
	}
	if (i>0&&!head)
	{
		printf("无法找到要插入的位置\n");
		free(p);
		return head;
	}
	if (i>0&&head)  //在非空的循环链表中位置i插入值为x
	{
		q = head;
		int j = 1;
		while (i!=j&&q->next!=head)
		{
			q = q->next;
			j++;
		}
		if (i==j)  //找到对应的位置i，进行插入操作
		{
			p->next = q->next;
			q->next = p;
			printf("%5d插入成功\n", x);
			return head;
		}
		else
		{
			printf("表中不存在第%d个结点，无法进行插入\n");
			return head;
		}
	}
}

/*
在循环链表中删除一个值为x的结点
返回指向头结点的指针
*/

node* dele(node* head, datatype x)
{
	node* pre = NULL, * q;//q用来指向要删除值为x的结点，pre是要删除结点的前驱。
	if (!head)
	{
		printf("循环单链表为空，无法进行删除操作\n");
		return head;
	}
	q = head;
	while (q->next!=head&&q->info!=x)
	{
		pre = q;
		q = q->next;
	}
	if (q->info==x)  //找到要删除的结点
	{
		if (q != head)
		{
			pre->next = q->next;
			free(q);
		}
		else if (q->next==head)  
		{
			free(q);
			head = NULL;
		}
		else {      //要删除的是第一个结点
			pre = head->next;
			while (pre->next!=q)
			{
				pre = pre->next; //找到q的前驱结点的位置
			}
			head = head->next;
			pre->next = head;
			free(q);
		}
	}
	return head;
}

//查询链表的长度
int length(node* head)
{
	node* p;
	p = head;
	int num = 0;
	if (!p)
	{
		printf("该链表为空\n");
	}
	while (p->next!=head)
	{
		num++;
		p = p->next;
	}
	return num;
}
  1. 运行结果

在这里插入图片描述
在这里插入图片描述

GUET_一路向前
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 循环单链表的简单操作
09-11
C语言 数据结构里面的，循环单链表的简单操作
实现循环单链表的各种基本运算的算法
04-17
数据结构与算法 李春葆 第五版实验报告2.22 含代码和结果
循环单链表的实现
So_discrepancy的博客
10-24 518
定义：将单链表中终端节点的指针端有空指针改为头节点，就使整个单链表形成一个环，这种头尾相接的单链表成为单循环链表。#include "string.h" #include "ctype.h"#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h"#define OK 1 #de
数据结构_单循环链表_C语言实现
m0_59519697的博客
05-09 552
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录二、使用步骤1.引入库2.读入数据总结 单循环链表 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 初始化 typedef struct Node { int data; struct Node* next; }Node; Node* initList() { Node* L = (Node*)malloc(s.
循环单链表（C语言实现）
Mr_John
10-26 514
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int DataType; typedef struct Node { DataType data; // 数据域 struct Node * next; // 指针域 }LinkList; LinkList* Init_List(); // ...
C语言实现的循环单链表功能示例
08-27
主要介绍了C语言实现的循环单链表功能,结合实例形式分析了基于C语言实现的循环单链表定义、创建、添加、删除、打印、排序等相关操作技巧,需要的朋友可以参考下
数据结构 C语言实现循环单链表的实例
08-30
主要介绍了数据结构 C语言实现循环单链表的实例的相关资料,需要的朋友可以参考下
数据结构中单链表的操作用C语言实现
最新发布
09-23
适用于大学生计算机学科学习数据结构
循环链表C语言实现
02-03
代码包含以下功能，经过产品验证，代码运行可靠。 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素； 9.将游标重置指向链表中的第一个数据元素； 10.将游标移动指向到链表中的下一个数据元素； 11.直接指定删除链表中的某个数据元素。
循环链表的理论知识与api的设计实现
qq_31990987的博客
06-18 186
一、循环链表的定义：将单链表中最后一个数据元素的next指针指向第一个元素。二、循环链表的操作：循环链表拥有单链表的所有操作。    1. 创建链表    2. 销毁链表    3. 获取链表的长度    4. 清空链表    5. 获取pos位置的元素    6. 插入元素到pos位置    7. 删除pos位置的元素三、游标的定义（新增的功能）    在循环链表中可以定义一个“当前指针”，通常...
简单理解单链表、双链表、循环单链表、循环双链表
ytswld的博客
11-03 647
简单理解单链表、双链表、循环单链表、循环双链表 单链表只有后继指针 双链表有后继指针和前驱指针 循环单链表尾指针指向了头指针 循环双链表头结点的前驱指针指向了尾结点，尾结点的后继指针指向了头结点 ...
c++单链表以及循环单链表的实现以及操作
HZPHYT的博客
02-15 1330
 单链表: #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; typedef struct node{ int data; node* next; }Node,*PNode; int getlen(PNode pn){ int i=0; PNode p=pn-&gt;next; while(p!=NULL){ i++; p=p-&g...
C语言—循环单链表
Long_UP的博客
12-07 885
#include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct lnode { ElemType data; struct lnode *next; }LNode,*LinkList; int CreateLinkList(LinkList &L,int num) //创建循环单链表 { int i; LinkList s,p; p = L = (LNode *)malloc(si
数据结构—循环链表的实现与分析
留恋单行路_Blog
09-13 1755
文章向导 从单链表到循环链表 引入多态的特性简化实现 创建一个循环链表 合并两个任意长度循环链表 一、从单链表到循环链表 　　对于一般的单链表，假设我们正处于表中的某一个节点，并想以此为起点来遍历整个链表。但显然这是无法做到的，我们只能从头节点再次重新开始遍历。 　　于是，循环链表也就应运而生，从而填补这种从单链表中任一节点开始遍历整个链表的需求。下图就是一个实际...
数据结构：Java实现循环单链表(超详细）
qq_51066068的博客
04-09 6876
java实现循环链表 实现一个循环链表（单链表），具备增加元素、删除元素、打印循环链表等功能。 一丶单向循环链表 就是为尾节点指向头结点 二丶单向循环链表的接口设计 比较单向链表,单向循环链表只需要修改添加节点,删除节点两个方法,也就是add和remove方法 三丶单向循环链表的实现 3.1添加节点 相比于单向链表,单向循环链表只需要特别关注插入头结点的情况即可 需要考虑的特殊情况是当链表的长度为0的时候的插入的情况 创建节点类 package LoopTable;...
循环链表的实现
qq_21110983的博客
02-17 743
企业链表节点实现循环链表，可以给大家一个参考。关于企业链表的不同可以参考我另外一篇文章，单链表中的讲解。 循环链表和普通链表的不同，在于链表节点最后的指向问题，在单链表中最后的节点指向是NULL，但是循环链表中最后的指向又再一次的指向了头节点，好处是，要多次要循环输出链表的时候就可以不需要额外设置变量，而是直接相应的倍数。但相应的改变就是在于删除或者插入节点到某个位置时，寻找上一个节点时候的停止搜索条件就应该相应的更改为辅助节点指向头节点的时候停止搜索，而不是一直指向NULL的时候。 #include&lt
单循环链表的实现
剑啸江湖
01-25 4052
循环链表(Circular Linked List)是一种首尾相接的链表,它与单链表的唯一区别在于对尾结点的处理；因为在单链表中尾结点的指针域NULL改为指向头结点就得到了单循环链表。单循环链表可以用头指针head或尾指针rear表示，用尾指针rear表示的单循环链表查找开始结点a1和尾结点an就很方便；查找时间都是O(1)。  仅设尾指针rear的单循环链表的实现：#incl
链表的从尾到头打印（四种方法）
龙跃十二
12-17 7689
一、单链表从尾到头打印的四种方法。 1、正常从尾到头打印。 用一个尾指针指到最后，尾指针每次前移移位，遇到尾指针则打印。void EndToFirstPrintNode(SListNode*ps) //正常从尾到头打印 { SListNode *cur=ps; SListNode *tail=NULL; while (ps != tail) { c
C 循环单链表
qq_44347816的博客
10-20 53
#include<stdio.h> #include<stdlib.h> struct listnode *heap; typedef struct listnode { int data; struct listnode *next; }listnode; listnode * creatlist() { listnode * temp; listnode *p; listnode *a; int i; temp = (listnode*)malloc(siz.
循环单链表的冒泡排序 c语言
03-26
以下是循环单链表的冒泡排序的C语言代码实现： ```c #include #include // 定义循环单链表的结构体 typedef struct Node { int data; struct Node *next; } Node, *LinkedList; // 创建循环单链表 LinkedList...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值