单向循环链表——插入、删除、实现约瑟夫环、排序

于 2024-02-03 22:52:18 发布
阅读量733 收藏 9
点赞数 10
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Duxingke_/article/details/136013427
版权
本文详细介绍了如何在C语言中实现单向循环链表的操作，包括头插、头删、尾插、尾删功能，以及约瑟夫环和两种排序算法（冒泡排序与简单选择排序）的编程实现。
摘要由CSDN通过智能技术生成

2024年2月3日
1.请编程实现单向循环链表的头插，头删、尾插、尾删

自定义头文件：

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;
Linklist create();
Linklist insert_head(Linklist head,datatype element);
Linklist insert_rear(Linklist head,datatype element);
void output(Linklist head);
Linklist delete_head(Linklist head);
Linklist delete_rear(Linklist head);

#endif

主函数：

#include"head.h"
int main(int argc, const char *argv[])
{
	datatype element;
	int num;
	Linklist head=NULL;
	printf("please enter num:");
	scanf("%d",&num);
	for(int i=0;i<num;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
		//head=insert_head(head,element);
		head=insert_rear(head,element);
	}
	output(head);
	puts("");
	head=delete_head(head);
	output(head);
	puts("");
	head=delete_rear(head);
	output(head);
	return 0;
}

自定义函数:

#include"head.h"
/*
 * function:    创建新节点
 * @param [ in] 
 * @param [out] 成功返回首地址，失败返回ＮＵＬＬ
 * @return      
 */
Linklist create()
{
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(s==NULL)
		return NULL;
	s->data=0;
	s->next=s;
	return s;
}
/*
 * function:   头插
 * @param [ in] 头　插入的值
 * @param [out] 头
 * @return      
 */
Linklist insert_head(Linklist head,datatype element)
{
	Linklist s=create();
	s->data=element;
	if(head==NULL)
	{
		head=s;
	}
	else
	{
		Linklist p=head;
		while(p->next!=head)
			p=p->next;
		s->next=head;
		head=s;
		p->next=head;
	}
	return head;
}
/*
 * function:    尾插　
 * @param [ in] 头　插入值
 * @param [out] 头
 * @return      
 */
Linklist insert_rear(Linklist head,datatype element)
{
	Linklist s=create();
	s->data=element;
	if(head==NULL)
	{
		head=s;
		return head;
	}
	Linklist p=head;
	while(p->next!=head)
	{
		p=p->next;
	}
	p->next=s;
	s->next=head;
	return head;
}
/*
 * function:    遍历输出
 * @param [ in] 头
 * @param [out] 
 * @return      
 */
void output(Linklist head)
{
	if(head==NULL)
	{
		puts("empty");
		return;
	}
	Linklist p=head;
	do
	{
		printf("%-5d",p->data);
		p=p->next;
	}while(p!=head);
}
/*
 * function:    头删
 * @param [ in] 头
 * @param [out] 头
 * @return      
 */
Linklist delete_head(Linklist head)
{
	if(head==NULL)
		return head;
	Linklist del=head;
	Linklist p=head;
	while(p->next!=head)
		p=p->next;
	p->next=head->next;
	head=head->next;
	free(del);
	return head;
}
/*
 * function:    尾删
 * @param [ in] 头
 * @param [out] 头
 * @return      
 */
Linklist delete_rear(Linklist head)
{
	if(head==NULL)
		return NULL;
	if(head->next==head)
	{
		free(head);
		head=NULL;
		return head;
	}
	Linklist p=head;
	while(p->next->next!=head)
	{
		p=p->next;
	}
	Linklist del=p->next;
	free(del);
	del=NULL;
	p->next=head;
	return head;
}

尾插、头删、尾删

头插、头删、尾删

⒉请编程实现单向循环链表约瑟夫环
约瑟夫环:用循环链表编程实现约瑟夫问题
n个人围成一圈，从某人开始报数1,2, .; m，数到m的人出圈，然后从出圈的下一个人(m+1)开始重复此过程，直到全部人出圈，于是得到一个出圈人员的新序列
如当n=8，m=4时，若从第一个位置数起，则所得到的新的序列为4,8,5,2,1,3,7,6。

头文件：

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;
Linklist create();
Linklist insert_rear(Linklist head,datatype element);
void output(Linklist head);
Linklist joseph(Linklist head,int n,int m);

#endif

主函数：

#include"head.h"
int main(int argc, const char *argv[])
{
	datatype element;
	int num;
	Linklist head=NULL;
	printf("please enter num:");
	scanf("%d",&num);
	for(int i=0;i<num;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
		head=insert_rear(head,element);
	}
	output(head);
	puts("");
	int m;
	printf("please enter m:");
	scanf("%d",&m);
	head=joseph(head,num,m);
	return 0;
}

自定义函数：

/*
 * function:    创建新节点
 * @param [ in] 
 * @param [out] 成功返回首地址，失败返回ＮＵＬＬ
 * @return      
 */
Linklist create()
{
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(s==NULL)
		return NULL;
	s->data=0;
	s->next=s;
	return s;
}
/*
 * function:    尾插　
 * @param [ in] 头　插入值
 * @param [out] 头
 * @return      
 */
Linklist insert_rear(Linklist head,datatype element)
{
	Linklist s=create();
	s->data=element;
	if(head==NULL)
	{
		head=s;
		return head;
	}
	Linklist p=head;
	while(p->next!=head)
	{
		p=p->next;
	}
	p->next=s;
	s->next=head;
	return head;
}
/*
 * function:    遍历输出
 * @param [ in] 头
 * @param [out] 
 * @return      
 */
void output(Linklist head)
{
	if(head==NULL)
	{
		puts("empty");
		return;
	}
	Linklist p=head;
	do
	{
		printf("%-5d",p->data);
		p=p->next;
	}while(p!=head);
}
Linklist joseph(Linklist head,int n,int m)
{
	if(NULL==head)
		return head;
	Linklist p=head;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m-2;j++)
		{
			p=p->next;
		}
		printf("%-5d",p->next->data);
		Linklist del=p->next;
		p->next=del->next;
		free(del);
		del=NULL;
		p=p->next;
	}
}

3.请编程实现单向循环链表的排序

头文件：

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;
Linklist create();
Linklist insert_rear(Linklist head,datatype element);
void output(Linklist head);
void bubble(Linklist head,int num);
void simple(Linklist head);

#endif

主函数：

#include"head.h"
int main(int argc, const char *argv[])
{
	datatype element;
	int num;
	Linklist head=NULL;
	printf("please enter num:");
	scanf("%d",&num);
	for(int i=0;i<num;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
		head=insert_rear(head,element);
	}
	output(head);
	puts("");
	//bubble(head,num);
	simple(head);
	output(head);
	return 0;
}

自定义函数：

#include"head.h"
/*
 * function:    创建新节点
 * @param [ in] 
 * @param [out] 成功返回首地址，失败返回ＮＵＬＬ
 * @return      
 */
Linklist create()
{
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(s==NULL)
		return NULL;
	s->data=0;
	s->next=s;
	return s;
}
/*
 * function:    尾插　
 * @param [ in] 头　插入值
 * @param [out] 头
 * @return      
 */
Linklist insert_rear(Linklist head,datatype element)
{
	Linklist s=create();
	s->data=element;
	if(head==NULL)
	{
		head=s;
		return head;
	}
	Linklist p=head;
	while(p->next!=head)
	{
		p=p->next;
	}
	p->next=s;
	s->next=head;
	return head;
}
/*
 * function:    遍历输出
 * @param [ in] 头
 * @param [out] 
 * @return      
 */
void output(Linklist head)
{
	if(head==NULL)
	{
		puts("empty");
		return;
	}
	Linklist p=head;
	do
	{
		printf("%-5d",p->data);
		p=p->next;
	}while(p!=head);
}
void bubble(Linklist head,int num)
{
	if(NULL==head)
		return;	
	for(int i=1;i<num;i++)
	{
		Linklist p=head;
		for(int j=0;j<num-i;j++)
		{
			if(p->data>p->next->data)
			{
				datatype t=p->data;
				p->data=p->next->data;
				p->next->data=t;
			}
			p=p->next;
		}
	}
}
/*
 * function:    简单选择排序
 * @param [ in] 头
 * @param [out] 
 * @return      
 */
void simple(Linklist head)
{
	if(NULL==head)
		return;
	for(Linklist i=head;i->next!=head;i=i->next)
	{
		Linklist min=i;
		for(Linklist j=i->next;j!=head;j=j->next)
		{
			if(min->data>j->data)
				min=j;
		}
		if(min!=i)
		{
			datatype t=i->data;
			i->data=min->data;
			min->data=t;
		}
	}
}

冒泡排序：

简单选择排序：

Duxingke_
关注
数据结构——链表
张许平的博客
03-17 541
链表也是一种数据结构，相比较于数组，略显复杂。链表和数组都是非常基础、非常常用的数据结构。 1. 数组与链表的区别 从底层的存储结构上看，二者申请的内存空间不一样： 数组需要一块连续的内存空间来存储，对内存要求较高。 链表不需要一块连续的内存空间，它通过"指针"将一组零散的内存块串联起来。 例如，当我们申请一个100MB大小的数组，当内存空间中没有连续的、足够大的存储空间时，即便内存的...
【数据结构与算法】-＞数据结构-＞链表-＞LRU缓存淘汰算法的实现
欢迎来到新世界
04-11 845
链表Ⅰ 链表与数组Ⅱ 链表结构链表在缓存的应用 Ⅰ 链表与数组 相比数组，链表是一种稍微复杂一点的数据结构。这两个非常基础，非常常用的数据结构，我们常常会放到一起来比较。所以我们先来看看，这两个数据结构有什么区别。 从底层的存储结构上看，数组在我的上一篇文章里已经讲过，申请的空间是连续的，对内存的要求比较高。如果我们申请一个大小为 100MB 的数组，当内存的连续存储空间没有 100MB ，就会申...
029. 排序的循环链表 C++
LB_AUTO的博客
10-08 452
029. 排序的循环链表 题目说明 给定循环升序列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。 如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。 如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。 示例 1： 输入：head = [3,4,1], insertVal =
LeetCode 排序的循环链表
fengzhubuliuxue的博客
08-20 350
2021.8.20 剑指 Offer II 029 排序的循环链表(med) 题目： 给定循环升序列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。 如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。 如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。 示例 1： 输入：hea
[Offer29] 排序的循环链表
Abider2的博客
05-26 307
个人向 题目 给定循环单调非递减列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。 如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。 如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。 来源：力扣（LeetCode） 链接：https://leetcode.cn/problem
剑指 Offer II 029. 排序的循环链表（中等 链表）
weixin_43942435的博客
02-20 514
剑指 Offer II 029. 排序的循环链表 给定循环单调非递减列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。 如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。 如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。 示例 1： 输入：head = [3,4,1], ins
C语言版---双向循环链表排序，冒泡排序，选择排序，插入排序，快速排序，应有尽有，取之不尽用之不竭，交换节点版本，没有bug，保证看懂!
AABond的博客
08-14 3211
C语言版---双向循环链表排序，冒泡排序，选择排序，插入排序，快速排序，应有尽有，取之不尽用之不竭，交换节点版本，没有bug，保证看懂!
约瑟夫问题解决与数据结构实验——链表实现
实验者通过单向循环链表来模拟约瑟夫问题，展示了如何创建链表、删除节点以及处理具体问题。 在实验中，约瑟夫问题的解决方法采用了单向循环链表的数据结构。单向循环链表由Node结构体定义，包括序号（num）和密码...
单向链表操作详解（二）[The End]
rerli的专栏
12-08 7627
/*接着讲（测试编译时，请把相应的函数及测试代码放到上一讲代码的相关地方）：排序（选择、插入、冒泡）插入（有序）*//*===============================================作者：rerli时间：2003-12-08目的：学习单向链表的创建、修改、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序说明：编译没有任何
厚积薄发打卡Day110：链表（九）排序的循环链表
COOLGWAYNE_TECH_BLOG
12-31 337
厚积薄发打卡Day110：链表（九）<排序的循环链表> 排序的循环链表 问题：在一个循环链表中节点的值递增排序，请设计一个算法在该循环链表中插入节点，并保证插入节点之后的循环链表仍然是排序的。例如，图4.15（a）所示是一个排序的循环链表，插入一个值为4的节点之后的链表如图4.15（b）所示。 实现 /** * 排序的循环链表 */ public class SortedCycleNodeList { public static ListNode insert(ListNod
万字长文，链表排序算法——冒泡排序、选择排序、插入排序、归并排序、快速排序、计数排序、桶排序、基数排序精讲及python实现
最新发布
白话机器学习
06-04 4116
在数组排序中，常见的排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。而对于链表排序而言，因为链表不支持随机访问，访问链表后面的节点只能依靠next指针从头部顺序遍历，所以相对于数组排序问题来说，链表排序问题会更加复杂一点。下面先来总结一下适合链表排序与不适合链表排序的算法：冒泡排序选择排序插入排序归并排序快速排序计数排序桶排序基数排序。希尔排序。堆排序。希尔排序为什么不适合链表排序？希尔排序：希尔排序中经常涉及到对序列中第。
数据结构和算法第四天~单向循环链表、希尔排序、快速排序、常见排序算法效率比较
crazyhulu的博客
02-23 637
单向循环链表 #coding=utf8 class Node(object): """ 节点""" def __init__(self,elem): self.elem=elem self.next=None #node=Node(100) class SingleCycleList(object): """单向...
C语言数据结构篇——单循环链表的创建，插入，节点删除，打印等操作
热门推荐
Demo不是emo的博客
02-08 1万+
初识循环链表
数据结构-单向循环链表（初始化、插入结点、删除结点等操作）
Eddy的博客
07-24 7449
单向循环链表 单向循环链表：将单向链表的最后一个结点指向头结点形成一个环，即成为单向循环链表，可以通过其中任意一个结点出发访问到其他结点。单向循环链表的操作方法与单向链表相似，只是在于循环条件存在差异。 特点： 若链表为空，则头结点的next结点还是指向其本身，即head ->next=head； 尾节点的next指针指向head结点，即头尾相连； 通过判断当前结点的next结点是否与head结点相等，即可判断是否对单向循环链表遍历完成； 循环链表无须增加存储量，仅对单向链表的链接方式稍作改变，即
单向循环链表：增删改查
m0_61401170的博客
01-10 207
单向循环链表 数据结构 函数指针运用 c语言
单向循环链表的删除算法
qq_42727102的博客
04-02 3155
//单向循环链表在删除时必须要有前驱指针，删头时，头指针前驱是尾结点 //删除时，需要两指针联动 //t为尾指针 //删头时 for(t=h;t->next!=h;t=t->next); t->next=h->next; free(h); h=t->next; //删中间尾时,q为前驱指针 q->next=delp->next; free(delp); ...
（第19列）C语言：单链表删除操作，循环删除，直到不想再删除为止。
yzh2776680982的博客
02-09 1995
先看结果，是不是你们想要的： 我们还是一步一步的来：（完整代码在最后！） 第一步： 1、预处理命令： #include<stdio.h> #include<stdlib.h> #define LEN sizeof(struct student) 2、结构体类型： struct student { int num; float score; struct student *next; }; 3、声明： struct stud
【408篇】C语言笔记-第十二章（单链表的删除&考研真题实战）
weixin_45842494的博客
12-07 1365
删除操作流程图：通过流程图，我们写出代码： 对于删除元素的逻辑，可以用一张图来表示：分析：解读：第一阶段：如何找到链表的中间结点？定义两个指针pcur和ppre，让pcur指针每次走两步，ppre指针每次走一步，这样当pcur指针走到最后，那么ppre指针刚好在中间。指针p每次循环走两步，因此每一步都要注意判断是否为NULL。第二阶段：后一半链表设置为了L2，如何让L2原地逆置？首先我们要判断链表是否为空，如果为空，就返回。如果只有一个结点，也不需要逆置，直接返回。第三阶段：将L和L2链表合并，合并时轮流
6-1 循环单链表区间删除 （15 分）
09-14 1010
本题要求实现带头结点的循环单链表的创建和单链表的区间删除。L是一个带头结点的循环单链表，函数ListCreate_CL用于创建一个循环单链表，函数ListDelete_CL用于删除取值大于min小于max的链表元素。 函数接口定义： Status ListCreate_CL(LinkList &CL); void ListDelete_CL(L...
C语言实现约瑟夫环：单向循环链表解决方案
"C语言通过单向循环链表实现约瑟夫环问题的代码示例" 在计算机科学中，约瑟夫环（Josephus Problem）是一个经典的理论问题，它涉及到一个循环列表中的元素按照特定规则被逐步移除。在这个问题中，n个人围成一个圈，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值