C语言解决约瑟夫环问题

最新推荐文章于 2024-02-22 20:09:03 发布
最新推荐文章于 2024-02-22 20:09:03 发布
阅读量6.5k 收藏 109
点赞数 11
分类专栏： 数据结构习题 文章标签： c语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41829337/article/details/126238648
版权
题目

在这里插入图片描述

解答

  1. 法一：单循环链表

    	#include<stdio.h>
	#include<stdlib.h>
	
	//定义单循环链表数据结构
	typedef struct CNode{
		int data;
		struct CNode *next;
	}CNode;
	typedef CNode *CLinkList;
	
	//初始化一个指向头节点的指针，使头指针->next=头指针，头指针->data不做处理
	void InitList_L(CLinkList *L){
		(*L) = (CLinkList)malloc(sizeof(CNode));
		if(!(*L))
			exit(-2);
		(*L)->next = *L;  
	}
	
	//头插法建立单循环链表
	int CreateList_HL(CLinkList *L,int s[],int n){ //二级指针
		int i;
		CLinkList p;
		*L = (CLinkList)malloc(sizeof(CNode));
		if(!(*L))
			exit(-2);
		(*L)->next = *L;			//只有一个头节点head，就让next指向自己
		for(i=0; i<n; i++){
			p = (CLinkList)malloc(sizeof(CNode));
			if(!p)
				exit(-2);
			p->data = s[i];			//录入数据 
			p->next = (*L)->next;   //将头指针所指向的下一个结点的地址，赋给新创建结点的next 
			(*L)->next = p;		    //将新创建的结点的地址赋给头指针的下一个结点
		}
		return 1;
	} 
	
	//尾插法建立单循环链表
	int CreateList_TL(CLinkList *L,int s[],int n){
		int i;
		CLinkList p, q;	
		*L = (CLinkList)malloc(sizeof(CNode));
		if(!(*L))
			exit(-2);
		(*L)->next = *L;	//只有一个头节点head，就让next指向自己
		for(i=0,q=*L; i<n; i++){
			p = (CLinkList)malloc(sizeof(CNode));
			if(!p)
				exit(-2);
			p->data = s[i];	//录入数据 
			q->next = p;
			q = q->next;
		}
		q->next = *L;      //最后一个结点指向head
		return 1;
	}
	
	//求单循环链表的长度
	int ListLength(CLinkList L){
		CLinkList p;				
		int count;
		if(L){
			count = 0;
			p = L;			   //p指向头结点  
			while(p->next!=L){ //p没到表头
				count++;
				p = p->next;
			}
		}
		return count;
	} 
	
	//得到指向单循环链表第i个元素的指针
	CLinkList GetElemPtr(CLinkList L, int i){										
		int count;
		CLinkList p;
		if(L&&i>0){
			count = 1;
			p = L->next;
			while(p!=L && count<i){
				count++;
				p = p->next;
			}
			if(p!=L)   //L为头指针
				return p;
		}
		return NULL;
	}
	
	//单循环链表第i个位置插入元素e
	int ListInsert(CLinkList L, int i, int e){
		CLinkList p, s;
		int j;
		if(i<1 || i>ListLength(L)+1)	//插入位置不合理
			return 0;
		p = L;
		j = 0; 
		while(j<i-1){  //寻找第i-1个结点
			p = p->next;
			++j;
		}
		s = (CLinkList)malloc(sizeof(CNode));
		if(!s)
			exit(-2);
		s->data = e;
		s->next = p->next;
		p->next = s;
		return 1;		
	} 
	
	//单循环链表第i个位置删除元素e
	int ListDelete(CLinkList L, int i, int *e){
		CLinkList pre, p; 
		int j;
		if(i<1 || i>ListLength(L))	//删除位置不合理
			return 0;
		pre = L;
		j = 1; 
		while(pre->next && j<i){  //寻找第i个结点，并令pre指向其前驱 
			pre = pre->next;
			++j;
		}
		p = pre->next;
		pre->next = p->next;
		*e = p->data;
		free(p);
		p=NULL;
		return 1; 
	}
	
	//遍历单循环链表
	void ListTraverse(CLinkList L){
		CLinkList p;
		p = L->next;	  //p指向头结点，正向访问链表
		while(p!=L){
			printf("%d ",p->data);
			p = p->next;
		}
		printf("\n");
	}
	
	//判断单循环链表是否为空
	int ListEmpty(CLinkList L){
		if(L!=NULL && L->next==L)  //单循环链表存在并且只有头结点 
			return 1;
		else
			return 0;
	}
	
	/*
	用单循环链表解决约瑟夫环问题(带头结点)
	这里的单循环链表使用了带头结点的，方便找到表头的位置，但是由于头结点不存储元素，因此需要跳过头结点
	链表插入删除都比较方便，不需要移动大量元素，只需要移动指针即可，适合这一类问题
	*/
	void Algo(CLinkList L,int k,int m){ //从编号为k的人开始数，数到m的那个人出队列
		int count,i,j;  //count表示每次从1开始数，i用来找编号为k的结点的前驱
		CLinkList pre,p;
		pre=L;
		count=1,i=1,j=1; 
		/*寻找第k个结点，并令pre指向其前驱*/
		while(i<k){       
			if(pre->next==L) //跳过头结点
				pre=pre->next->next;
			else
			    pre = pre->next;
			++i;
		}
		while(L->next!=L){  //如果单循环链表不为空
			if(count==m){
				/*下一个结点不是头结点，直接删除*/
				if(pre->next!=L){  
					p=pre->next;
					printf("第%d次出环的元素是%d\n",j++,p->data);
					pre->next=p->next;
					free(p);
					p=NULL;
					count=1;
				}
				/*下一个结点是头结点，下下个结点不是头结点，跳过头结点，删除下下个结点（头结点不保存数据，因此不参与运算）*/
				else if(pre->next->next!=L){ 
					p=pre->next->next;
					printf("第%d次出环的元素是%d\n",j++,p->data);
					pre->next->next=p->next;
					free(p);
					p=NULL;
					count=1;
				}
				/*下一个结点是头结点，下下个结点也是头结点，说明单循环链表已经为空了,只剩下头结点，因此跳出循环*/
				else  
					break;
			}
			count++;        //count代表要删除的结点数的数，始终在pre指向的结点之前
			if(pre->next==L) //跳过头结点
				pre=pre->next->next; //pre指向要删除结点的前一个结点
			else
				pre = pre->next;     //pre指向要删除结点的前一个结点
		}
	}

	void main(){
		CLinkList L;
		int n=5,s[5]={1,2,3,4,5}; //假设5个人围坐一圈
		int k=3,m=2;              //第一次从编号为k的人开始数，数到m的那个人出队列
		CreateList_TL(&L,s,n);    //头插法建立单循环链表
		ListTraverse(L);          //遍历原始队列
		printf("假设第一次从编号为%d的人开始数，数到%d的那个人出环\n",k,m);
		Algo(L,k,m);       //用单循环链表解决约瑟夫环问题(带头结点)
	}

  2. 法二：循环数组

    	/*
	用循环数组解决约瑟夫环问题
	解决问题的难点有两个:
	1、如何求下一个的人的位置：在循环数组中向后移动采用：(k+l)%n
	2、此人出圈后对这个人的位置如何处理：先将出圈人的位置打印输出，然后将其位置元素设置为0，表示它已出圈，以后见到它就直接跳过去
	*/
	void Algo2(int s[],int n,int k0,int m){  //开始一共有n个人，从第k0个人开始数，数到m的那个人出队列
		int i,j,k=k0-1;     //元素访问的下标为 k，初始时从第k0个人开始数
	    for(i=0;i<n;i++){   //总共循环n次，每循环一次，出队一个元素，k在循环中会不断的运动
	        j=1;            //j表示数的数，初始为1
	        while(j<m){     //如果还没有数到m
	            while(s[k]==0) //如果s[k]为0，证明它已经出圈了，则跳过它
					k=(k+1)%n; 
	            j++;         //数下一个数
	            k=(k+1)%n;   //数组下标向后走一步
	        }
	        while(s[k]==0) //如果数到m发现它出圈了，则跳过它，找到第一个没出圈的数
				k=(k+1)%n;
	        printf("第%d次出环的元素是%d\n",i+1,s[k]); //先将出圈人的位置打印输出
	        s[k]=0; //然后将其位置元素设置为0，表示它已经出圈
	    }
	}

	void main(){
		int n=5,s[5]={1,2,3,4,5}; //假设5个人围坐一圈
		int k=3,m=2;              //第一次从编号为k的人开始数，数到m的那个人出队列
		printf("假设第一次从编号为%d的人开始数，数到%d的那个人出环\n",k,m);
		Algo2(s,n,k,m);    //用循环数组解决约瑟夫环问题
	}

  3. 法三：递归

    	/*
	用递归解决约瑟夫环问题
	n指的是总人数，m指的是每次最大报到的数值，i是第i次，该函数每次可以求出第i次扔海里的人的编号
	*/
	int Algo3(int n,int m,int i){
		if(i==1)
			return (n+m-1)%n;
		else
			return (Algo3(n-1,m,i-1)+m)%n;
	}

	void main(){
		int n=5; //假设5个人围坐一圈
		int m=2; //数到2的那个人出环             
		printf("假设第一次从编号为1的人开始数，数到%d的那个人出环\n",m);
		for(int i=1;i<=n;i++)
			printf("第%d次出环的元素是%d\n",i,Algo3(n,m,i)+1); //因为求出的结果是数组中的下标，最终的编号还要加1
	}

  4. 法四：迭代

    	/*
	用迭代解决约瑟夫环问题
	递推公式：
	f(N,M)=(f(N−1,M)+M)%N
	f(N,M)表示，N个人报数，每报到M时杀掉那个人，最终胜利者的编号
	f(N−1,M)表示，N-1个人报数，每报到M时杀掉那个人，最终胜利者的编号
	*/
	int Algo4(int n,int m){
		int i,p=0;
		for(i=2;i<=n;i++){
			p=(p+m)%i;
		}
		return p+1; //因为求出的结果是数组中的下标，最终的编号还要加1
	}

	void main(){
		int n=5; //假设5个人围坐一圈
		int m=2; //数到2的那个人出环
		printf("假设第一次从编号为1的人开始数，最后出环的是：%d\n",Algo4(n,m));
	}
happy life 2022
关注
  • 11
    点赞
  • 踩
  • 109
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言约瑟夫环的实现
12-31
C语言约瑟夫环的实现 一、典故:       据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是商量了一个自杀方式：       41个人排成一个圆圈，由第1个人 开始报数，每数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从，Josephus要 他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。 二、用循环链表实现 1.约瑟夫环实现 sListNod
约瑟夫环C语言代码
weixin_42864391的博客
08-24 1万+
/* 此为小程序多文件的写法,有 joseph.c joseph.h main.c makefile 四个文件 */ // include include include “joseph.h” joseph *joseph_insert(int num) { joseph *l = NULL; joseph *p = NULL; j...
C语言使用循环单链表实现Joseph（约瑟夫问题）
最新发布
m0_59793715的博客
02-22 154
C语言使用循环单链表实现Joseph（约瑟夫问题）
C语言数据结构-用链表解决约瑟夫环问题
zyqmeinv的博客
03-09 2799
简单易懂的C语言约瑟夫环
约瑟夫环问题（C语言数组和循环链表）
热门推荐
ss的博客
12-07 1万+
本文将用两种方式（数组和循环链表）求解约瑟夫环问题，为了更好理解，本文将从洛谷的P1996 约瑟夫问题出发。 题目描述 nn 个人围成一圈，从第一个人开始报数,数到 mm 的人出列，再由下一个人重新从 11 开始报数，数到 mm 的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。 输入格式 输入两个整数 n,m。 输出格式 输出一行 n个整数，按顺序输出每个出圈人的编号。 输入输出样例 输入 10 3 输出 3 6 9 2 7 1 8 5 10 4 说明/提示
数据结构—约瑟夫环问题(C语言版)
m0_73463638的博客
02-26 1万+
数据结构—约瑟夫环问题(C语言版)
约瑟夫环代码 c语言约瑟夫
07-16
约瑟夫环（Joseph）问题的一种描述是：编号为1、2、3……n的n个人按照顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数的上限值m，从第一个人开始按照顺时针的方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他的顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。
C语言约瑟夫环（简单版）
h18615619128的博客
11-21 7119
传说约瑟夫当年活下来就是靠快速计算这个问题。 n个人围成一圈，编号依次为1,2,3…n。从第一个人开始报数，数到m的人出列，再由下一个人重新从1开始报数，数到m的人再出圈。以此类推，直到所有的人都出列。请输出依次出圈人的编号。 输入格式 两个整数n,m，1≤n,m≤100。 输出格式 n个用空格分隔的整数，表示出圈人的编号。 输入样例： 6 4 输出样例： 4 2 1 3 6 5 解题思路：先输入人数和出圈的数，定义一个数初始化为0用来计数，同时作为循环条件，再定义一...
约瑟夫环问题（c语言实现）
ALWAYS LEARNING
12-21 9832
约瑟夫环问题问题描述算法1. 非递归法算法理解程序2. 递归法程序3. 循环双链表思路程序 问题描述 有N个人，编号为 1～n，围成一个圈，编号1的人手上有一个热狗开始向下一个人传递，在热狗传递 m 次后，此时拿着热狗的人退出，剩余的人围成一个圈，从退出的人的下一位再开始上述循环，知道最后一个留下来的人胜利。 如果n为5，m为1，则退出的人编号依次为2，4，1，5，最后胜利的是3。 算法 1. 非...
Java程序练习-约瑟夫环问题
道不同不相为谋
10-03 1038
约瑟夫环问题 时间限制: 1000ms内存限制: 1000kB 描述 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下
约瑟夫环（简单版）c语言解决
weixin_61009782的博客
11-21 2364
传说约瑟夫当年活下来就是靠快速计算这个问题。 n个人围成一圈，编号依次为1,2,3…n。从第一个人开始报数，数到m的人出列，再由下一个人重新从1开始报数，数到m的人再出圈。以此类推，直到所有的人都出列。请输出依次出圈人的编号。 输入格式 两个整数n,m， 1<=n,m<=100 输出格式 n个用空格分隔的整数，表示出圈人的编号。 #include<stdio.h> int main() {// 约瑟夫环的简单问题 int n,m,d=0,k=0,...
C语言基于循环链表解决约瑟夫环问题的方法示例
01-20
本文实例讲述了C语言基于循环链表解决约瑟夫环问题的方法。分享给大家供大家参考，具体如下： 概述： 约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（以编号1，2，3，…，n分别表示）围坐在一张圆桌...
c语言用数组方法解决约瑟夫环问题
12-10
这个题我是用数组下标置0方法做的，类似单链表的性质，这个方法是模拟了游戏过程，是比较笨的代码，喜欢研究的朋友可以用相关算法来实现。时间复杂度为O（n^2），代码注释很详细，基本每一行我都写了注释，稍微有点...
利用简洁的C语言代码解决跳台阶问题与约瑟夫环问题
09-02
主要介绍了利用简洁的C语言代码解决跳台阶问题与约瑟夫环问题的方法,跳台阶问题与约瑟夫环问题是常见的基础算法题目,需要的朋友可以参考下
约瑟夫环问题（C语言版）——双向循环链表和静态链表实现
weixin_43204126的博客
10-24 2777
文章目录题目描述双向循环链表静态链表法公式法 约瑟夫环问题，也称圆桌问题，解决的方案很多，在此，给出三种解决方案，双向循环链表，静态链表和公式法 题目描述 编号为1，2，…，n的n个人按顺时针方向围坐在一张圆桌周围，每人持有一个密码（正整数）。一 开始任选一个正整数m作为报数上限值，从第一个人开始按顺时针方向自1开始报数，报到m时停止报数，报m的那个人出列，将他的密码作为新的m值，从他顺时针方向的...
约瑟夫环的三种解法（C语言），数组+链表+递归
qq2745567641的博客
01-27 2176
问题描述：有n人围成一圈，顺序排号。从第1个人开始报数（从1到m报数），凡报到m的人退出圈子，问最后留下的是原来的第几号的那位。 （一）数组实现： #include<stdio.h> #include<stdlib.h> int main() { int n,m;//共n个人，数到m出局 int out=0,k=0,i; scanf("%d%d",&n,&m); int a[n]; for(i=0;i<n;i++)//初始化为0，为1表示已出局
约瑟夫环解法大全（C语言版）
L__ear的博客
04-15 9875
前言： 约瑟夫环不愧是一道经典的算法题，原来也经常看到，但一直没有动手编码研究。最近又被同学提起这个问题，就研究了一下，发现这个问题可以挖掘的东西有很多，怪不得一直是面试的热门问题。
C语言：约瑟夫环（简单版）
weixin_62690039的博客
11-18 2009
传说约瑟夫当年活下来就是靠快速计算这个问题。 nn个人围成一圈，编号依次为1,2,3…n。从第一个人开始报数，数到mm的人出列，再由下一个人重新从11开始报数，数到mm的人再出圈。以此类推，直到所有的人都出列。请输出依次出圈人的编号。 输入格式 两个整数n,mn,m，1\le n,m \le 1001≤n,m≤100。 输出格式 nn个用空格分隔的整数，表示出圈人的编号。 Sample Input 6 4 Sample Output 4 2 1 3 6 5 #...
神奇的约瑟夫环（C语言）
Yawesh的博客
07-27 6975
约瑟夫环问题是一个古老而引人入胜的数学问题，涉及人与人之间的生死较量。问题的背景是：n个人围坐成一圈，从第一个人开始按照一定规律进行报数，每报到特定数字的人会被淘汰，直到剩下最后一个人。本文将探讨约瑟夫环问题的解决方法和数学原理。首先介绍了三种常见的实现方式：数组、单链表和数学公式。针对每种方式，分析了其优缺点和适用场景。接着，阐述了约瑟夫环问题的数学公式解法，说明其高效的计算方法。最后，强调了解决约瑟夫环问题的意义，包括培养数学思维、算法思维和逻辑思维，以及在日常生活和实际应用中的潜在价值。
用c语言解决约瑟夫环问题处理
06-13
好的，约瑟夫环问题可以使用循环链表来解决，以下是使用C语言实现的示例代码： ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; void createList(struct Node** head, int n) { struct Node *prev, *cur; *head = (struct Node*)malloc(sizeof(struct Node)); (*head)->data = 1; prev = *head; for (int i = 2; i <= n; i++) { cur = (struct Node*)malloc(sizeof(struct Node)); cur->data = i; prev->next = cur; prev = cur; } prev->next = *head; } void josephus(struct Node** head, int k) { struct Node *prev, *cur; prev = *head; cur = (*head)->next; while (prev->next != prev) { for (int i = 1; i < k; i++) { prev = prev->next; cur = cur->next; } prev->next = cur->next; printf("%d ", cur->data); free(cur); cur = prev->next; } *head = prev; } int main() { int n, k; struct Node* head = NULL; printf("Enter the number of people: "); scanf("%d", &n); printf("Enter the elimination number: "); scanf("%d", &k); createList(&head, n); josephus(&head, k); printf("\nThe winner is: %d", head->data); return 0; } ``` 这段代码首先使用 `createList` 函数创建一个包含 `n` 个人的循环链表，然后使用 `josephus` 函数依次出列每第 `k` 个人，最后输出胜利者的编号。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值