循环链表——约瑟夫环问题

最新推荐文章于 2023-05-14 18:05:47 发布
最新推荐文章于 2023-05-14 18:05:47 发布
阅读量2.9k 收藏 14
点赞数 6
分类专栏： 每日练习 文章标签： 数据结构 链表 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laoKdx/article/details/125920307
版权

 老样子，先创建好结构体

typedef int datatype;

typedef struct Node
{
	union
	{
		datatype data;  //节点数据域
		int len;  //长度
	};

	struct Node *next; //指针域
}Looplink;

辅助函数：

创建链表头函数:

//创建
Looplink *list_create()
{
	Looplink *L=(Looplink*)malloc(sizeof(Looplink));
	if(NULL == L)
	{
		printf("创建失败\n");
		return NULL;
	}
	//初始化
	L->len=0;
	L->next=L;  //初始化时，头节点的指针域指向自己
	
	printf("创建成功\n");
	return L;

}

以及一部分辅助函数

//判空
int list_empty(Looplink *L)
{
	 return L->next==L? 1:0; //1表示空 0表示非空
}

//节点申请函数
Looplink* node_add(datatype e)
{
	Looplink *p = (Looplink*)malloc(sizeof(Looplink));
	if(NULL == p)
	{
		printf("节点申请失败\n");
		return NULL;
	}

	//数据存放
	p->data = e;
	p->next = NULL;
}

在主函数引导指定总数与步长，并存入循环链表

int m,n;
	printf("请制定数据总数:");
	scanf("%d",&m);
	printf("去指定选择步长:");
	scanf("%d",&n);
	Looplink *L = list_create();   //创建循环单向链表
	for(int i=0; i<m; i++)
	{
		list_insert_tail(L, i+1);  //把数据用尾插法放入链表
	}

然后为了避免头节点影响遍历步长，故删除头节点

//删除头节点，使循环链表变成约瑟夫环
	Looplink *p = kill_head(L);   //删除头节点函数
	//遍历
	list_show2(p);



/****************以下是用到的函数块*********************/

//链表断头
Looplink *kill_head(Looplink *L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return NULL;
	}
	//定义遍历指针定位到最后一个节点
	Looplink *q = L->next;
	while(q->next != L)
	{
		q=q->next;
	}
	//孤立头结点
	q->next=L->next;
	//删除头节点
	free(L);
	L=NULL;
	//返回第一个节点的位置
	printf("头结点删除成功\n");
	return q->next;
}
/***************************************/
//删除头节点的遍历
void list_show2(Looplink *S)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("遍历失败\n");
		return ;
	}
	//遍历
	printf("链表元素分别是\n");
	Looplink *q=S;
	do
	{
		printf("%d\t",q->data);
		q=q->next;
	}while(q!=S);
	printf("\n");
}

创建一个新的头，用以接受拆出来的链表元素

//创建一个新的头:S
	Looplink *S = list_create();

接下来，我们需要用指针p遍历链表，每四步断一次，然后把选中的元素，嫁接到新的链表头S上。同时要注意，

        一定不要把p直接放入嫁接函数！

        一定不要把p直接放入嫁接函数！

        一定不要把p直接放入嫁接函数！

重要的事情说三遍，不然会导致指针p指到只有一个元素的链表S内，导致段错误。故，应当设一个局部变量q，让它指向p，代替p进入嫁接函数。

//循环取值，逢n取1，到只剩一值时停下
	for(int i=0; i<m-1; i++ )
	{
		for(int j=0; j<n-1; j++)//因为P下面会多移一步，故步长为n-1
		{
			p = p->next;      
		}
		Looplink *q = p;   //工具人,让它去被拆掉，如果把p丢入函数，
                           //会导致p指向只有一个元素的链表S，从而导致段错误
		p = p->next;
		list_reverse(S, q);   //拆除嫁接函数
	}
	list_reverse(S, p);       //把最后剩下的数嫁接到S上

/*******************以下是使用到的相关函数***********************/

//拆出链表并嫁接
void list_reverse(Looplink *S ,Looplink *p)
{

	//查找前一个节点
	Looplink *q = find_node(p);        //前节点查找函数
	
    //孤立p
	q->next = p->next;
	p->next = NULL;
	
    //尾插法把p插入S
	Looplink *k=S;
	while(k->next != S)
	{
		k=k->next;
	}
	p->next = S;
	k->next = p;
	//
	S->len++;
	printf("尾插成功\n");
}

/********************上一个函数用到的节点查找函数************/
//查找上一个结点
Looplink *find_node(Looplink *L)
{
	//查找节点
	Looplink *q = L;
	while(q->next != L)   //当q下一位是L时停止
	{
		q = q->next;
	}
	return q;  //返回找到的节点
}

此时，我们已经得到了一个新的循环链表，只需要断掉最后一个元素与头节点S的连接，就能得到一个崭新出厂的顺序链表S了

//断开S与最后一位的链接
	Looplink *q=S;
	while(q->next != S)
	{
		q = q->next;
	}
	q->next = NULL;
	//遍历S，检验结果
	list_show(S);
	return 0;

/**********************顺序链表的遍历函数*******************/
//遍历
void list_show(Looplink *L)
{
	if(NULL == L || list_empty(L))  //先判断非法
	{
		printf("表空或表非法，遍历失败\n");
		return;
	}
	//遍历
	printf("链表元素为:");
	Looplink *q = L->next;
	while(q != NULL)
	{
		printf("%d\t",q->data);
		q = q->next;
	}
	printf("\n");
}

至此，我们便完成了这个问题

以下张贴完整代码，酌情观看。

/**********************main.c********************/
//主函数

#include<stdio.h>
#include<string.h>
#include"ysf.h"
int main(int argc, const char *argv[])
{
	int m,n;
	printf("请制定数据总数:");
	scanf("%d",&m);
	printf("去指定选择步长:");
	scanf("%d",&n);
	Looplink *L = list_create();   //创建循环单向链表
	for(int i=0; i<m; i++)
	{
		list_insert_tail(L, i+1);  //把数据用尾插法放入链表
	}

	//删除头节点，使循环链表变成约瑟夫环
	Looplink *p = kill_head(L);
	//遍历
	list_show2(p);
	
	//创建一个新的头:S
	Looplink *S = list_create();
	
	//循环取值，逢n取1，到只剩一值时停下
	for(int i=0; i<m-1; i++ )
	{
		for(int j=0; j<n-1; j++)//因为P下面会多移一步，故步长为n-1
		{
			p = p->next;
		}
		Looplink *q = p;   //工具人,让它去被拆掉
		p = p->next;
		list_reverse(S, q);
	}
	list_reverse(S, p);
	//断开S与最后一位的链接
	Looplink *q=S;
	while(q->next != S)
	{
		q = q->next;
	}
	q->next = NULL;
	//遍历S，检验结果
	list_show(S);
	return 0;
}

功能函数文件

/**********************ysf.h*******************/

#include<stdio.h>
#include<stdlib.h>
#include"ysf.h"
//创建
Looplink *list_create()
{
	Looplink *L=(Looplink*)malloc(sizeof(Looplink));
	if(NULL == L)
	{
		printf("创建失败\n");
		return NULL;
	}
	//初始化
	L->len=0;
	L->next=L;  //初始化时，头节点的指针域指向自己
	
	printf("创建成功\n");
	return L;

}

//判空
int list_empty(Looplink *L)
{
	 return L->next==L? 1:0; //1表示空 0表示非空
}

//节点申请函数
Looplink* node_add(datatype e)
{
	Looplink *p = (Looplink*)malloc(sizeof(Looplink));
	if(NULL == p)
	{
		printf("节点申请失败\n");
		return NULL;
	}

	//数据存放
	p->data = e;
	p->next = NULL;
}

//查找上一个结点
Looplink *find_node(Looplink *L)
{
	//查找节点
	Looplink *q = L;
	while(q->next != L)
	{
		q = q->next;
	}
	return q;  //返回找到的节点
}


//循环链表的尾插法
int list_insert_tail(Looplink *L,datatype e)
{
	//判断
	if(NULL==L)
	{
		printf("所给链表不合法\n");
		return -1;
	}
	//申请节点
	Looplink *p = node_add(e);

	//插入逻辑
	Looplink *q=L;
	while(q->next != L)
	{
		q = q->next;
	}
	p->next=L;
	q->next=p;
	//表的变化
	L->len++;
	printf("尾插成功\n");
}

//链表断头
Looplink *kill_head(Looplink *L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return NULL;
	}
	//定义遍历指针定位到最后一个节点
	Looplink *q = L->next;
	while(q->next != L)
	{
		q=q->next;
	}
	//孤立头结点
	q->next=L->next;
	//删除头节点
	free(L);
	L=NULL;
	//返回第一个节点的位置
	printf("头结点删除成功\n");
	return q->next;
}

//拆出链表并嫁接
void list_reverse(Looplink *S ,Looplink *p)
{

	//查找前一个节点
	Looplink *q = find_node(p);
	//孤立
	q->next = p->next;
	p->next = NULL;
	//尾插法把p插入S
	Looplink *k=S;
	while(k->next != S)
	{
		k=k->next;
	}
	p->next = S;
	k->next = p;
	//
	S->len++;
	printf("尾插成功\n");
}

//遍历
void list_show(Looplink *L)
{
	if(NULL == L || list_empty(L))  //先判断非法
	{
		printf("表空或表非法，遍历失败\n");
		return;
	}
	//遍历
	printf("链表元素为:");
	Looplink *q = L->next;
	while(q != NULL)
	{
		printf("%d\t",q->data);
		q = q->next;
	}
	printf("\n");
}

//删除头节点的遍历
void list_show2(Looplink *S)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("遍历失败\n");
		return ;
	}
	//遍历
	printf("链表元素分别是\n");
	Looplink *q=S;
	do
	{
		printf("%d\t",q->data);
		q=q->next;
	}while(q!=S);
	printf("\n");
}

最后是头文件

#ifndef __YSF__
#define __YSF__

typedef int datatype;

typedef struct Node
{
	union
	{
		datatype data;  //节点数据域
		int len;  //长度
	};

	struct Node *next; //指针域
}Looplink;

//创建
Looplink *list_create();

//查找上一个节点
Looplink *find_node(Looplink *L);

//判空
int list_empty(Looplink *L);

//节点申请函数
Looplink* node_add(datatype e);

//尾插
int list_insert_tail(Looplink *L,datatype e);

//链表断头
Looplink *kill_head(Looplink *L);

//拆出链表并嫁接
void list_reverse(Looplink *S ,Looplink *p);

//遍历
void list_show(Looplink *L);

//删除头节点的遍历
void list_show2(Looplink *S);

#endif

老K殿下
关注
  • 6
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
循环链表解决约瑟夫环问题
liu_shi_的博客
03-25 3445
循环链表解决约瑟夫环问题
【数据结构】单向环形链表解决约瑟夫问题
dengmsjava的博客
05-13 747
单向环形链表解决约瑟夫问题 用一个不带头结点的单向环形链表来处理Josephu问题：先构成一个有n个结点的单循环链表,然后由k结点起从1开始计数，计到m时，对应结点从链表中册除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
约瑟夫循环-链表
cswf_sh的博客
12-15 227
链表之报数问题 描述 有n个人围成一圈，顺序从1开始排号。从第1个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。建议用循环链表实现。 算法概要：定义环形链表（双向），每当数到3后，将这一节点从链表中去除。 当节点的下一节点等于其自身时，只剩下该节点，退出循环，即找到了最后一人。
环形链表解释约瑟夫问题
IT小辉同学
05-14 866
单向链表、双向链表和环形链表都是常见的链表数据结构，它们在不同场景下具有不同的特点和优缺点。
单向循环链表 解决约瑟夫问题
m0_72310503的博客
07-22 140
代码】单向循环链表解决约瑟夫问题。
约瑟夫环——c/c++循环链表实现
06-09
建立从1到n的序列，按照一定次序出列。输出出列次序，并找出最后一个出列的序号
C/C++经典约瑟夫环问题——带头结点的单向循环链表
03-24
本程序是采用带头结点的单向循环链表写成的，当指针指到要出列的结点时，先输出结点的序列号，再删除之，直到所有结点都出列完
数据结构——制作约瑟夫环
05-17
约瑟夫环问题是一个经典的理论问题，源自古罗马数学家约瑟夫提出的一个假设情景：在战争...这个实现通过循环链表有效地处理了约瑟夫环问题，展示了链表操作如插入、遍历和删除节点的能力，同时也体现了算法设计的技巧。
猴王（约瑟夫衍生问题）程序
01-13
对于一个约瑟夫环问题的衍生问题———选猴王问题的解决程序，采用循环链表结构解决（源码中有详细注释）
数据结构——约瑟夫环
11-26
数据结构——约瑟夫环 约瑟夫环是一种典型的数据结构问题，它是指在一个环形链表中，删除第 m 个节点的过程。这里，我们将深入探讨约瑟夫环的实现细节和相关知识点。 1. 环形链表的实现 在约瑟夫环问题中，我们...
循环链表实现约瑟夫环问题
11-06
循环链表实现约瑟夫环问题 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
约瑟夫问题用循环链表实现
11-09
约瑟夫问题是一个经典的问题。已知n个人（不妨分别以编号1，2，3，…，n 代表）围坐在一张圆桌周围，从编号为 k 的人开始，从1开始顺时针报数1, 2, 3, ...，顺时针数到m 的那个人，出列并输出。然后从出列的下一个人开始，从1开始继续顺时针报数，数到m的那个人，出列并输出，…依此重复下去，直到圆桌周围的人全部出列。 输入：n,k,m 输出：按照出列的顺序依次输出出列人的编号，编号中间相隔一个空格,每10个编号为一行。 非法输入的对应输出如下 a) 输入：：n、k、m任一个小于1 输出：n,m,k must bigger than 0. b) 输入：k>n 输出：k should not bigger than n. 例 输入 9,3,2 输出 4 6 8 1 3 7 2 9 5
单循环链表解决约瑟夫环问题
Aladdin的思考
12-26 180
     这几天为了准备笔试忙着复习C语言，决定把当时学C时的一些经典问题再温习一下，当时啊，学的稀里糊涂的，呵呵，现在回头来仔细写一写代码，就算是纪念当时的个性十足的赵老师了吧！     约瑟夫问题的：编号为1，2，....,N的N个人按顺时针方向围坐一圈,每人持有一个密码(正整数)，一开始任选一个正整数作为报数上限值M，从第一个人开始按顺时针方向自1开始顺序报数，报到M时停止报数。报M的人出列...
约瑟夫环问题（循环单链表）
兔子王
09-21 1377
约瑟夫环问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。
【C语言】单向循环链表（实例详解约瑟夫问题）
m0_60511809的博客
11-27 3951
类似单链表，循环链表也是一种链式的存储结构，由单链表演化而来。 单向循环链表来源于单链表，所以单链表的基本操作基本都适合于循环链表。两者的不同点主要表现在链表的建立和链表表尾的判断。 接下来我们通过分析一个经典的问题即 “ 约瑟夫问题 ”来理解单循环链表。 “ 约瑟夫问题 ” 简单来说就是：有n个人围成一个圈，规定一个数字num，从某个人开始报数，每次从1报到这个数字num，报到num的人出列，现在要我们按顺序输出...
（四）约瑟夫问题-单向环形链表
Apikaqiu的博客
05-17 326
约瑟夫问题 问题描述： 设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到m 的那个人出列， 它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 思路：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开 始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下
单向环形链表介绍以及约瑟夫问题分析
周小末天天开心的博客
11-27 1121
单向环形链表的介绍以及约瑟夫问题的分析与解答
循环链表模拟约瑟夫问题
勿上的博客
03-02 354
问题来历：        据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个...
约瑟夫问题-循环链表
何解然_K|user
08-30 392
循环链表直接贴代码： #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; typedef struct node { int data; struct node *next; }kill; kill *create(int n)//返回结构体指针 { kill *head,*p=NULL;//创建头指针 head=(kill*)ma...
c语言使用循环链表解决约瑟夫环问题
最新发布
06-02
下面是使用循环链表解决约瑟夫环问题的C语言实现： ``` #include #include typedef struct node { int num; struct node *next; } Node; void create_circle(Node **head, int n) { Node *tail = NULL, *p =...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

老K殿下

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值