约瑟夫问题—顺序表完美实现

合集下载

约瑟夫问题

一问题描述1 题目内容：约瑟夫(Joseph)问题的一种描述是:编号为1,2,..., n的n 个人按顺时针方向围坐一圈, 每人持有一个密码(正整数)。

一开始选任一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。

报m的人出列，将它的密码作为新的m值。

试设计一个程序求出出列顺序。

2 基本要求：利用单项循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

3 测试数据：m的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4（正确的出列顺序应为6，1，4，7，2，3，5）。

二需求分析程序运行后，首先要求用户指定初始报数上限值，然后读取个人的密码。

输入数据：建立输入处理输入数据，输入m的初值，n ，输入每个人的密码，建立单循环链表。

输出形式：建立一个输出函数，将正确的输出序列三概要设计利用单项循环链表存储结构模拟此过程1 循环链表的抽象数据类型循环链表是单链表的一种变化形式，把单链表的最后一个节点的next指针指向第一个节点，整个链表就形成了一个环。

2 循环链表的基本操作（仅列出用在本程序的）creat(n)操作结果：构造一个长度为n的无头节点的循环链表,并返回指向最后一个节点的指针find(m,s)初始条件：循环链表存在操作结果：找到当前元素（即s）后面第m个元素print(&m,&n,&s)初始条件：循环链表存在操作结果：从s中删除约舍夫问题中下一个被删除的元素，并将此元素显示在屏幕上3 本程序包括4个模块：主程序模块；创建循环链表模块；找节点模块；删节点模块；各模块调用关系如下图所示：4 约舍夫问题的伪码算法void main( ){输入参与的人数；输入第一个密码；创建无头节点的循环链表；输出第一个出列元素；输出剩余出列元素；}四详细设计1 实现概要设计的数据类型typedef struct LNode{int data;int num;struct LNode *next;}LNode,*linklist; //无头节点的循环链表的节点类型2 每个子函数的算法linklist creat(int n){/*构造一个长度为n的无头节点的循环链表,并返回指向最后一个节点的指针*/linklist head,s; //head为头节点标记s为链表中节点int i;s=head=(linklist)malloc(sizeof(LNode)); //创建头节点for(i=1;i<n;i++) //建立循环链表{s->data=i;printf("num%d: ",i);scanf("%d",&(s->num));/*输入第i个人的密码*/while(s->num<=0){/*如果输入的s->num小于等于0,要求重新输入*/ printf("请重新输入\nnum%d: ",i);scanf("%d",&s->num);}s->next=(linklist)malloc(sizeof(LNode)); //开辟下一个节点s=s->next;}s->data=i;printf("num%d: ",i);scanf("%d",&(s->num));s->next=head;return(s);}linklist find(int m,linklist s) //找到当前元素后面第m个元素{int i;for(i=0;i<m-1;i++)s=s->next;return(s); //返回找到元素的指针}void print(into &mint &n,linklist &s){linklist p;s=find(m,s); //找到待删除的元素printf("%d ",s->next->data);/*输出找到的元素*/m=s->next->num;/*将此元素从链表中删除,并释放此节点*/ p=s->next;s->next=s->next->next;free(p);--n; //约舍夫环中节点数少一}3 主程序算法void main( ){/*解决约舍夫问题的主函数*/int n,m; //n为约舍夫环内初始人数m为初始密码printf("type in n :");scanf("%d",&n);/*输入n*/while(n<=0){/*如果输入的n小于等于0,要求重新输入*/printf("please type n in again \ntype in n :");scanf("%d",&n);}printf("type in m :");scanf("%d",&m);/*输入m*/while(m<0){/*如果输入的m小于0,要求重新输入*/printf("please type m in again \ntype in m :");scanf("%d",&m);}linklist s;s=creat(n);/*创建无头节点的循环链表,返回指向最后一个元素的指针*/printf("the sequence is ");print(m,n,s);//输出第一个出列的元素while(n){print(m,n,s);//输出剩余出列的元素}printf("\n");}4 函数调用关系图五调试分析调试过程中出现过如下问题：1 开始编程序时没考虑输入错误的问题，导致输入错误后程序出错2 编程序时删除节点子程序结束条件出错3 对开辟的节点用完后没有释放六使用说明程序运行后按提示输入n和m的值，在输入约舍夫环中每个人的密码，运行即可得到出列顺序七测试结果进入程序后要求输入n的值然后输入m的值再输入每个人的密码最后得到出列顺序八附录（源程序）这里附上两种源程序，本质上相同，只是第一个程序按老师要求写为很多子函数形式，第二个是我已开始编的，一个大函数。

数据结构实验报告

姓名：学号：班级：2010年12月15日实验一线性表的应用【实验目的】1、熟练掌握线性表的基本操作在顺序存储和链式存储上的实现。

、；2、以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3、掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；4、通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作）。

【实验内容】约瑟夫问题的实现：n只猴子要选猴王，所有的猴子按1,2，…，n编号围坐一圈，从第一号开始按1,2…，m报数，凡报到m号的猴子退出圈外，如此次循环报数，知道圈内剩下一只猴子时，这个猴子就是猴王。

编写一个程序实现上述过程，n和m由键盘输入。

【实验要求】1、要求用顺序表和链表分别实现约瑟夫问题。

2、独立完成，严禁抄袭。

3、上的实验报告有如下部分组成：①实验名称②实验目的③实验内容：问题描述：数据描述：算法描述：程序清单：测试数据算法：#include <stdio.h>#include <stdlib.h>typedef struct LPeople{int num;struct LPeople *next;}peo;void Joseph(int n,int m) //用循环链表实现{int i,j;peo *p,*q,*head;head=p=q=(peo *)malloc(sizeof(peo));p->num=0;p->next=head;for(i=1;i<n;i++){p=(peo *)malloc(sizeof(peo));p->num=i;q->next=p;p->next=head;}q=p;p=p->next;i=0;j=1;while(i<n){if(j%m==0){q->next=p->next;p=q->next;printf("%4d",j%n);i++;}else{q=p;p=p->next;}j++;}printf("\n");}void main(){int n,m; /*人的个数*/printf("Please Enter n amd m(n>m):\n");scanf("%d%d",&n,&m);Joseph(n,m);}实验二树和图的应用【实验目的】1．熟练掌握数的基本概念、二叉树的基本操作及在链式存储结构上的实现。

约瑟夫环问题实验报告

约瑟夫问题实验报告背景约瑟夫问题（Josephus Problem）据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。

然而Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

原题：用户输入M,N值，N个人围成一个环，从0号人开始数,数到M,那个人就退出游戏，直到最后一个人求最后一个剩下的人是几号？问题描述设编号为1-n的n(n>0)个人按顺时针方向围成一圈．首先第1个人从1开始顺时针报数．报m的人(m 为正整数)．令其出列。

然后再从他的下一个人开始，重新从1顺时针报数，报m的人，再令其出列。

如此下去，直到圈中所有人出列为止。

求出列编号序列。

一.需求分析：(1)基本要求需要基于线性表的基本操作来实现约瑟夫问题需要利用循环链表来实现线性表（2）输入输出格式输入格式：n，m(n,m均为正整数，)输出格式1：在字符界面上输出这n个数的输出序列(3)测试用例（举例）输入：8，4输出：4 8 5 2 1 3 7 6二．概要设计（1）抽象数据类型：数据对象：n个整数数据关系：除第一个和最后一个n外，其余每个整数都有两个元素与该元素相邻。

基本操作：查找，初始化，删除，创建链表循环链表的存储结构:（2）.算法的基本思想循环链表基本思想：先把n个整数存入循环链表中，设置第m个数出列，从第一个开始查找，找到第m个时，输出第m个数，并删掉第m个节点，再从下一个数开始查找,重复上一步骤，直到链表为空，结束。

（3）.程序的流程程序由三个模块组成：1.输入模块：完成两个正整数的输入，存入变量n和m中2.处理模块：找到第m个数3.输出模块：按找到的顺序把n个数输出到屏幕上三．详细设计首先，设计实现约瑟夫环问题的存储结构。

约瑟夫环问题

约瑟夫环问题问题描述：有n个⼈，编号分别从0到n-1排列，这n个⼈围成⼀圈，现在从编号为0的⼈开始报数，当报到数字m的⼈，离开圈⼦，然后接着下⼀个⼈从0开始报数，依次类推，问最后只剩下⼀个⼈时，编号是多少？分析：这就是著名的约瑟夫环问题，关于来历不再说明，这⾥直接分析解法。

解法⼀：蛮⼒法。

我曾将在⼤⼀学c语⾔的时候，⽤蛮⼒法实现过，就是采⽤标记变量的⽅法即可。

解法⼀：循环链表法。

从问题的本质⼊⼿，既然是围成⼀个圈，并且要删除节点，显然符合循环链表的数据结构，因此可以采⽤循环链表实现。

解法三：递推法。

这是⼀种创新的解法，采⽤数学建模的⽅法去做。

具体如下：⾸先定义⼀个关于n和m的⽅程f(n,m)，表⽰每次在n个编号0，1，...，n-1中每次删除的报数为m后剩下的数字，在这n个数字中，第⼀个被删除的数字是(m-1)%n，为了简单，把(m-1)%n记作k，那么删除k之后剩下的数字为0，1，2，...，k-1，k+1，...，n-1并且下⼀次删除的数字从k+1开始计数，这就相当于剩下的序列中k+1排在最前⾯，进⽽形成k+1,..,n-1,0,1,2,...,k-1这样的序列，这个序列最后剩下的数字应该和原序列相同，由于我们改变了次序，不能简单的记作f(n-1,m),我们可以记作g(n-1,m),那么就会有f(n,m)=g(n-1,m).下⼀步，我们把这n-2个数字的序列k+1,..,n-1,0,1,2,...,k-1做⼀个映射，映射的结果是形成⼀个从0到n-2的序列。

k+1对0，k+2对1，......，n-1对n-k-2，0对n-k-1，1对n-k，....，k-1对n-2这样我们可以把这个映射定义为p,则p(x)=(x-k-1)%n,它表⽰如果映射前的数字是x，映射后为(x-k-1)%n,从⽽这个映射的反映射问为p-1(x)=(x+k+1)%n由于映射之后的序列和原始序列具有相同的形式，都是从0开始的序列，所以可以⽤函数f来表⽰，即为f(n-1,m)，根据映射规则有：g(n-1,m)=p-1[f(n-n,m)]=[f(n-1,m)+k+1]%n,最后把之前的k=(m-1)%n带⼊式⼦就会有f(n,m)=g(n-1,m)=[f(n-1,m)+m]%n.这样我们就可以得出⼀个递推公式，当n=1时，f(n,m)=0;当n>1时，f(n,m)=[f(n-1,m)+m]%n;有了这个公式，问题就变得多了。

实验一：约瑟夫问题

实验一：约瑟夫问题问题描述：用数组和链表存储方式实现约瑟夫问题。

约瑟夫问题：n个人围成一个圆圈，首先第1个人从1开始一个人一个人顺时针报数，报到第m个人，令其出列。

然后再从下一个人开始，从1顺时针报数，报到第m个人，再令其出列，…，如此下去，直到圆圈中只剩一个人为止。

此人即为优胜者。

基本要求：用顺序存储和链式存储方式实现。

试验报告内容：1．问题描述：设有n个人围坐在圆桌周围，现从某个位置m（1≤m≤n）上的人开始报数，报数到k 的人就站出来。

下一个人，即原来的第k+1个位置上的人，又从1开始报数，再报数到k的人站出来。

依此重复下去，直到全部的人都站出来为止。

2. 算法描述：可以先建一个单向循环链表；而整个“约瑟夫环”问题的过程，最终是把这个链表删空为止。

但在删时不能顺着删，而是按该问题的方案来删。

3.源程序#include <stdio.h>#include <stdlib.h>#define MAX_NODE_NUM 100#define TRUE 1U#define FALSE 0Utypedef struct NodeType{int id; /* 编号 */int cipher; /* 密码 */struct NodeType *next;} NodeType;/* 创建单向循环链表 */static void CreaList(NodeType **, const int);/* 运行 "约瑟夫环 "问题 */static void StatGame(NodeType **, int);/* 打印循环链表 */static void PrntList(const NodeType *);/* 得到一个结点 */static NodeType *GetNode(const int, const int);/* 测试链表是否为空, 空为TRUE，非空为FALSE */static unsigned EmptyList(const NodeType *);int main(void){int n, m;NodeType *pHead = NULL;while (1){printf( "请输入人数n（最多%d个）: ", MAX_NODE_NUM); scanf( "%d ", &n);printf( "和初始密码m: ");scanf( "%d ", &m);if (n > MAX_NODE_NUM){printf( "人数太多，请重新输入！\n ");continue;}elsebreak;}CreaList(&pHead, n);printf( "\n------------ 循环链表原始打印 -------------\n "); PrntList(pHead);printf( "\n-------------- 出队情况打印 ---------------\n "); StatGame(&pHead, m);printf( "\n\ "约瑟夫环\ "问题完成!\n ");return 0;}static void CreaList(NodeType **ppHead, const int n){int i, iCipher;NodeType *pNew, *pCur;for (i = 1; i <= n; i++){printf( "输入第%d个人的密码: ", i);scanf( "%d ", &iCipher);pNew = GetNode(i, iCipher);if (*ppHead == NULL){*ppHead = pCur = pNew;pCur-> next = *ppHead;}else{pNew-> next = pCur-> next;pCur-> next = pNew;pCur = pNew;}}printf( "完成单向循环链表的创建!\n ");}static void StatGame(NodeType **ppHead, int iCipher){int iCounter, iFlag = 1;NodeType *pPrv, *pCur, *pDel;pPrv = pCur = *ppHead;/* 将pPrv初始为指向尾结点，为删除作好准备 */while (pPrv-> next != *ppHead)pPrv = pPrv-> next;while (iFlag) /* 开始搞了! */{/* 这里是记数，无非是移动iCipher-1趟指针! */for (iCounter = 1; iCounter < iCipher; iCounter++) {pPrv = pCur;pCur = pCur-> next;}if (pPrv == pCur) /* 是否为最后一个结点了 */iFlag = 0;pDel = pCur; /* 删除pCur指向的结点，即有人出列 */pPrv-> next = pCur-> next;pCur = pCur-> next;iCipher = pDel-> cipher;printf( "第%d个人出列, 密码: %d\n ",pDel-> id, /* 这个编号标识出列的顺序 */pDel-> cipher);free(pDel);}*ppHead = NULL; /* 没人了！为了安全就给个空值 */}static void PrntList(const NodeType *pHead){const NodeType *pCur = pHead;if (EmptyList(pHead))return;do{printf( "第%d个人, 密码: %d\n ", pCur-> id,pCur-> cipher); pCur = pCur-> next;} while (pCur != pHead);}static NodeType *GetNode(const int iId, const int iCipher){NodeType *pNew;pNew = (NodeType *)malloc(sizeof(NodeType));if (!pNew){printf( "Error, the memory is not enough!\n ");exit(-1);}pNew-> id = iId;pNew-> cipher = iCipher;pNew-> next = NULL;return pNew;}static unsigned EmptyList(const NodeType *pHead){if (!pHead){printf( "The list is empty!\n ");return TRUE;}return FALSE;}4.实验测试数据（要求有多组）：第一组测试结果人数n为7, 初始密码m为20第1个人, 密码: 3第2个人, 密码: 1第3个人, 密码: 7第4个人, 密码: 2第5个人, 密码: 4第6个人, 密码: 8第7个人, 密码: 4-------------- 出队情况打印 ---------------第6个人出列, 密码: 8第1个人出列, 密码: 3第4个人出列, 密码: 2第7个人出列, 密码: 4第2个人出列, 密码: 1第3个人出列, 密码: 7第5个人出列, 密码: 4第二组测试结果人数n为8, 初始密码m为15第1个人, 密码: 5第2个人, 密码: 4第3个人, 密码: 3第4个人, 密码: 2第5个人, 密码: 9第6个人, 密码: 1第7个人, 密码: 7第8个人, 密码: 8-------------- 出队情况打印 ---------------第7个人出列, 密码: 7第6个人出列, 密码: 1第8个人出列, 密码: 8第3个人出列, 密码: 3第1个人出列, 密码: 5第4个人出列, 密码: 2第2个人出列, 密码: 4第5个人出列, 密码: 95.总结：1. 通过本次上机实践,对链表存储结构有了更深的理解和把握.2. 通过本次上机实践,应用链表的知识解决和分析问题的能力有了新的提高.3. 通过上机实践,掌握了用高级语言实现算法的基本步骤和方法.（最前面加班级、学号、姓名）。

约瑟夫问题的链式求解法

实验一约瑟夫问题求解一、实验目的1、掌握上机调试线性表的基本方法；2、掌握线性表的基本操作：插入、删除、查找等运算在顺序存储结构和链式存储结构上的运算。

3、掌握约瑟夫问题求解算法二、实验内容1、认真阅读和掌握本实验的参考程序，并上机运行本程序，可尝试完善删除、查找等运算。

2、参考第二章课件中对瑟夫问题求解算法的描述，选择一种存储结构实现该问题的求解。

三、注意事项：1、在磁盘上创建一个目录，专门用于存储数据结构实验的程序，可通过U盘或邮箱长期保存程序。

2、实验报告要求：（1）算法的完整代码；（2）程序运行结果及分析；（3）实验总结。

四、参考程序1、顺序表的插入(1)程序代码#include "stdio.h"#include "stdlib.h"typedef struct SeqList{int data[100];int length; /* 表长*/}SeqList , *PSeqList;PSeqList creaeNullList_seq()/* 创建空线性表*/{PSeqList palist=(PSeqList)malloc(sizeof(struct SeqList));if(palist!=NULL){palist->length=0;return(palist);}printf("Out of space!!\n");return NULL;}int isNullList_seq(PSeqList palist)/* 判断是否空线性表*/{return (palist->length==0);}int insertPre_seq(PSeqList palist,int p,int x){int q;if(palist->length>=100){printf("overflow!\n");return(0);}if(p<0 || p>palist->length){printf("Not exist!\n");return(0);}if(isNullList_seq(palist)){palist->data[0]=x;palist->length=1;return(1);}for(q=palist->length-1;q>=p;q--)palist->data[q+1]=palist->data[q] ;palist->data[p]=x;palist->length= palist->length+1;return(1);}void main(){int i;PSeqList list;list=creaeNullList_seq(); /* 创建空线性表*/printf("插入前的顺序表为：\n ");for(i=0;i<=9;i++){insertPre_seq(list,i,i*i);printf(" %d " , list->data[i]);}insertPre_seq(list,5,55);/*在下标为5的元素之前插入元素55*/ printf("\n\n插入后的顺序表为：\n ");for(i=0;i<list->length;i++)printf(" %d " , list->data[i]);printf("\n\n");}（2）运行结果2、约瑟夫问题顺序表的实现int josephus_ SeqList (PSeqList josephus_seq, int s, int m){ /*求解约瑟夫问题的出列元素序列入口参数：已经存放数据的顺序表，起始位置s，数m , 出口参数：1表示成功，0表示表中没有元素*/int s1,i,w;if ( ! josephus_seq->length){ printf(“表中无元素”);return (0); }s1=s - 1; /*data数组中下标从0开始*/printf(“输出约瑟夫序列：”);for( i= josephus_seq->length; i>0; i --;){ s1=(s1+m-1)% i; /*找到出列元素的下标*/w= josephus_seq->data[s1];printf(“%d\t”, w)Delete_SeqList(josephus_seq，s1); /*删除出列元素*/} /*for */return（1）; /*成功返回*/}3、约瑟夫问题链表的实现int josephus_ LinkList (LinkList josephus_Link, int s, int m){ /*求约瑟夫问题的出列元素序列，入口参数：已经存放数据的链表头指针的地址，起始位置s，数m ,出口参数：1表示成功，0表示表中没有元素*/LinkList p,pre; /*p指向当前结点，pre指向其前驱结点*/int count;if ( ! josephus_Link){ printf(“表中无元素”);return (0);}/*找第s个元素*/p= josephus_Link;for(count=1;count<s;count++) /*查找第s个结点，用p作为第s个结点的指针*/p=p->next;printf(“输出约瑟夫序列：”);while ( p!=p->next) /*输出n-1个元素个结点*/{ for(count=1;count<m;count++){ pre=p;p=p->next;} /*for*/printf(“%d\t”, p->data);pre->next=p->next;free(p);p=pre->next;}/*while*/printf(“%d\t”,p->data); /*输出最后一个元素个结点*/free(p);return 1;}2．约瑟夫问题的求解（1）程序代码#include"stdio.h"#include"stdlib.h"typedef struct node{int data;struct node *next;}lnode,*linklist;linklist Init_josephus(void){linklist head;head=(linklist)malloc(sizeof(lnode));if(!head){printf("Apply place is faliure!\n\n");return NULL;}head->next=NULL;return head;}void Create_josephus(linklist JOS){linklist p,q,H;int x;p=H=JOS;printf("please enter elements:\n");scanf("%d",&x);p->data=x;scanf("%d",&x);while(x!=-1){q=(linklist)malloc(sizeof(lnode));q->data=x;q->next=p->next;p->next=q;p=q;scanf("%d",&x);}p->next=H;p=H;printf("\n");while(p->next!=H){printf("%3d",p->data);p=p->next;}printf("%3d",p->data);printf("\n");}int josephus_linklist(linklist josephus_link,int s,int m){linklist p,pre;int count;if(!josephus_link){printf("There are not have elements in the list!\n");return 0;}p=josephus_link;for(count=1;count<s;count++)p=p->next;printf("The list of josephus is :\n");while(p!=p->next){for(count=1;count<m;count++){pre=p;p=p->next;}printf("%d\t",p->data);pre->next=p->next;free(p);p=pre->next;}printf("%d\t",p->data);free(p);printf("\n");return 1;}main(){int i,j;lnode *Josephus;Josephus=Init_josephus();Create_josephus(Josephus);printf("please enter the first elements number and steps:\n");scanf("%d%d",&i,&j);josephus_linklist(Josephus,i,j);return 2;}（2）程序运行结果（3）实验总结这次实验用的是链式存储结构来解决约瑟夫问题，第一遍编写的程序中，指针使用的有点混乱，头结点不知该如何处理，指针问题解决后，在运行的过程中，头结点的问题一直解决不了即创建的表有问题还没有解决，表的创建中数据的输出里一个很大的数，原因就是头结点中的值域为空；后来将两个结构体类型的指针同时指向头指针，才将问题顺利解决。

工作报告之约瑟夫环实验报告总结

约瑟夫环实验报告总结【篇一：约瑟夫环实验报告】实验报告课程名称：数据结构实验名称：顺序表和链表的应用实验编号：实验一指导教师：一、实验目的（1）掌握线性表的基本操作（插入、删除、查找）以及线性表合并等运算在顺序存储结构、链式存储结构上的实现。

重点掌握链式存储结构实现的各种操作。

（2）掌握线性表的链式存储结构的应用。

二、实验内容与实验步骤（1）实验内容：实现约瑟夫环，约瑟夫环（joseph）问题的一种描述是：编号为1、2、3……n的n个人按照顺时针方向围坐一圈，每人持有一个密码（正整数）。

一开始任选一个正整数作为报数的上限值m，从第一个人开始按照顺时针的方向自1开始顺序报数，报到m时停止报数。

报m的人出列，将他的密码作为新的m值，从他的顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。

设计一个程序求出出列顺序。

（2）抽象数据类型和设计的函数描述，说明解决设想。

首先定义一个链表，用其中的data项存储每个人的编号，用password项存储每个人所持有的密码，并且声明一个指针。

之后使用creatlist_cl函数来创建一个循环链表，在其中的data和password中存入编号和密码，最后使最后一个节点的next指向l，使其能够形成循环队列。

定义了函数display来显示链表当中的内容，以确定存储的数据没有错误。

定义了函数delete_l来实现约瑟夫环中依次删除的功能，依次比较，如果某个人所持的密码和m值相等，则删除这个结点，并且输出此时该结点的编号和密码，实现出列的功能。

（3）简短明确地写出实验所采用的存储结构，并加以说明。

该实验我主要采用的是线性表的链式存储结构，首先定义了链表的结构，其中包括data项和password项，分别存储每个人的编号和所持密码，还声明了指向下一个结点的指针，该指针可以连接各个结点，并且将最后一个结点的指针指向第一个结点使之成为一个循环链表。

三、实验环境操作系统：windows 7调试软件名称：vc++版本号：6.0上机地点：综合楼311四、实验过程与分析（1）主要的函数或操作内部的主要算法，分析这个算法的时、空复杂度，并说明设计的巧班级：学号：姓名：组号：实验成绩：批阅教师签字：实验日期：实验时间：妙之处。

约瑟夫问题大全

“约瑟夫”问题及若干变种林厚从例1、约瑟夫问题(Josephus)[问题描述]M只猴子要选大王，选举办法如下：所有猴子按1…M编号围坐一圈，从第1号开始按顺序1，2，…，N报数，凡报到N的猴子退出到圈外，再从下一个猴子开始继续1~ N报数，如此循环，直到圈内只剩下一只猴子时，这只猴子就是大王。

M和N由键盘输入，1≤N,M≤10000，打印出最后剩下的那只猴子的编号。

例如，输入8 3，输出：7。

[问题分析1]这个例题是由古罗马著名史学家Josephus提出的问题演变而来的，所以通常称为Josephus(约瑟夫)问题。

在确定程序设计方法之前首先来考虑如何组织数据，由于要记录m只猴子的状态，可利用含m 个元素的数组monkey来实现。

利用元素下标代表猴子的编号，元素的值表示猴子的状态，用monkey[k]=1表示第k只猴子仍在圈中，monkey[k]=0则表示第k只猴子已经出圈。

程序采用模拟选举过程的方法，设变量count表示计数器，开始报数前将count置为0，设变量current表示当前报数的猴子编号，初始时也置为0，设变量out记录出圈猴子数，初始时也置为0。

每次报数都把monkey[current]的值加到count上，这样做的好处是直接避开了已出圈的猴子（因为它们对应的monkey[current]值为0），当count=n时，就对当前报数的猴子作出圈处理，即：monkey[current]：=0，count：=0，out：=out+1。

然后继续往下报数，直到圈中只剩一只猴子为止（即out=m-1）。

参考程序如下：program josephus1a {模拟法，用数组下标表示猴子的编号}const maxm=10000;var m,n,count,current,out,i:integer;monkey:array [1..maxm] of integer;beginwrite('Input m,n:');readln(m,n);for i:=1 to m do monkey[i]:=1;out:=0; count:=0; current:=0;while out<m-1 dobeginwhile count<n dobeginif current<m then current:=current+1 else current:=1;count:=count+monkey[current];end;monkey[current]:=0; out:=out+1; count:=0end;for i:=1 to m doif monkey[i]=1 then writeln('The monkey king is no.',i);readlnend.[运行结果]下划线表示输入Input m，n:8 3The monkey king is no.7 {时间：0秒}Input m，n:10000 1987The monkey king is no.8544 {时间：3秒}[反思]时间复杂度很大O(M*N)，对于极限数据会超时。

数据结构约瑟夫环问题

数据结构实验报告题目：约瑟夫环问题一．设计内容[问题描述]约瑟夫环问题的一种描述是：编号为1, 2, 3,…，n的n个人按顺时针方向围坐一圈，每人手持一个密码（正整数）。

一开始任选一个整数作为报数上限值，从第一人开始顺时针自 1 开始顺序报数,报到m 时停止报数。

报m 的人出列, 将它的密码作为新的m 值,从他在顺时针方向上的下一个人开始重新从 1 报数, 如此下去直到所有人全部出列为止。

试设计程序实现之。

[基本要求] 利用循环链表存储结构模拟此过程,按照出列的顺序打印各人的编号。

[ 实验提示] 程序运行后首先要求用户指定初始报数上限值。

然后读取各人的密码。

设n<=30 。

程序执行后,要求用户在计算机终端上显示“提示信息”后,用键盘输入“提示信息”中规定的命令,以“回车符”为结束标志。

相应的输入数据和运算结果显示在其后。

二、设计目的1. 达到熟练掌握C++ 语言的基本知识和技能；2. 能够利用所学的基本知识和技能,解决简单的面向对象程序设计问题。

3. 把课本上的知识应用到实际生活中,达到学以致用的目的。

三、系统分析与设计（确定程序功能模块）1、为实现上述程序的功能,应以有序链表表示集合。

基本操作：InitList(&L)操作结果：构造一个空的有序表L。

DestroyList(&L)初始条件：有序表L 已存在。

操作结果：销毁有序表L。

ListEmpty(L)初始条件：有序表L 已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE。

ListLength(L)初始条件：有序表L 已存在。

操作结果：返回L 中数据元素个数。

GetElem(L,i)初始条件：有序表L已存在，并且K i< ListLength(L)。

操作结果：返回L 中第i 个数据元素。

LocatePos(L,e)初始条件：有序表L已存在，e和有序表中元素同类型的值。

操作结果：若L中存在和e相同的元素，则返回位置；否则返回0。

约瑟夫问题详解（CC++）

约瑟夫问题详解（CC++）Josephus 约瑟夫问题假设n个竞赛者排成一个环形，依次顺序编号1，2，…，n。

从某个指定的第1号开始，沿环计数，每数到第m个人就让其出列，且从下一个人开始重新计数，继续进行下去。

这个过程一直进行到所有的人都出列为止。

最后出列者为优胜者。

无论是用链表实现还是用数组实现来解约瑟夫问题都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较麻烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。

注意到原问题仅仅是要求出最后的胜利者的序号，而不是要模拟整个过程。

因此如果要追求效率，就要打破常规，实施一点数学策略。

为了讨论方便，先把问题稍微改变一下，并不影响原意：问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。

求胜利者的编号。

我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k=m%n的人开始）: k k+1 k+2 ... n-2, n-1, 0, 1, 2, ... k-2并且从k开始报0。

现在我们把他们的编号做一下转换：k --> 0k+1 --> 1k+2 --> 2......k-2 --> n-2变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x 是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗？变回去的公式很简单：x'=(x+k)%n如何知道(n-1)个人报数的问题的解？显然，只要知道(n-2)个人的解就行了。

(n-2)个人的解呢？当然是先求(n-3)的情况---- 这显然就是一个倒推问题！递推公式：令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]递推公式f[1]=0;f[i]=(f[i-1]+m)%i; (i>1)有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。

《数据结构》上机实验报告—约瑟夫环问题

福州大学数计学院
《数据结构》上机实验报告
专业和班级：信息计算科学与应用数学6班
学号
姓名
成绩
实验名称
线性表结构及其应用
实验内容
约瑟夫环问题
实
验
目
的
和
要
求
【实验目的】
利用单向循环链表解决约瑟夫环问题，提高综合设计能力。
【基本要求】
利用单向循环链表存储结构模拟此过程,按归口炪列的顺序印出各人的编号.
问
题
描
i=1；
while（i<=n)
｛
printf（”请输入第％d个人的密码：”，i);
scanf（"％d",&pwd)；
if(pwd〈= 0)continue；
Insert(L，pwd, i）；
i++;
｝
i = 1；
p = L-〉next；
while（L->next！= L）
｛
q = p;
p = p->next;
【结果截图】
研
究
与
探
讨
解决约瑟夫环问题有三个算法：
一个是在顺序表上实现，另一个是在单向循环链表上实现，第三个则是利用循环队列的方式来实现。
说明：实验名称为教学大纲中各章的实验项目名称,实验内容为具体章节的实验内容名称
述
和
主
要
步
骤
【问题描述】
约瑟夫问题：编号为1，2，。。n的n个人按顺时针方向围坐一圈，每人持有一个密码(正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列,将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止.试设计一个程序求出出列顺序.

c语言实现约瑟夫环问题解析

（一）基本问题1.问题描述设有编号为1,2,…,n的n（n＞0）个人围成一个圈，每个人持有一个密码m。

从第一个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m 时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。

当任意给定n和m后，设计算法求n个人出圈的次序。

建立模型，确定存储结构。

对任意n个人，密码为m，实现约瑟夫环问题。

2.数据结构设计首先，设计实现约瑟夫环问题的存储结构。

由于约瑟夫环问题本身具有循环性质，考虑采用循环链表，为了统一对表中任意结点的操作，循环链表不带头结点。

将循环链表的结点定义为如下结构类型：struct Node{int data;Node *next;};其次，建立一个不带头结点的循环链表并由头指针first指示3.算法设计1、工作指针first，r，s，p，q初始化2、输入人数（n）和报数（m）3、循环n次，用尾插法创建链表Node *q;for(int i=1;i<=n;i++){Node *p;p=new Node;p-> data =i;p->next=NULL;if(i==1) L=q=p;else{q->next=p;q=q->next;}}q->next=L;if(L!=NULL){return(L);}4、输入报数的起始人号数k;5、Node *q = new Node;计数器初始化i=1;6、循环n次删除结点并报出位置（其中第一个人后移k个）当i<n时移动指针m-2次p=p->next;删除p结点的后一结点qq=p->next;p->next=q->next;*L = p->next;报出位置后Delete q;计数器i++;运行流程图代码和相关解释#include<iostream>using namespace std;struct Node//循环节点的定义{int data;//编号Node *next;};Node *CreateList(Node *L,int &n,int &m);//建立约瑟夫环函数void Joseph(Node *L,int n,int m);//输出每次出列号数函数Node *DeleteList(Node **L,int i,Node *q);//寻找每次出列人的号数int LengthList(Node *L);//计算环上所有人数函数void main()//主函数//在主函数中，完成人数（n）和报数（m）的输入和工作指针的初始化{Node *L;L=NULL;//初始化尾指针int n, m;cout<<"请输入人数N：";cin>>n;//环的长度if(n<1){cout<<"请输入正整数!";}//人数异常处理else{cout<<"请输入所报数M：";cin>>m;if(m<1){cout<<"请输入正整数!";}//号数异常处理else{L=CreateList(L,n,m);//重新给尾指针赋值Joseph(L,n,m);}}system("pause");}Node *CreateList(Node *L,int &n,int &m)//建立一个约瑟夫环（尾插法）{Node *q;for(int i=1;i<=n;i++){Node *p;p=new Node;p->data=i;p->next=NULL;if(i==1) L=q=p;//工作指针的初始化else{q->next=p;q=q->next;}}q->next=L;if(L!=NULL){return(L);}//返回尾指针else cout<<"尾指针异常!"<<endl;//尾指针异常处理}void Joseph(Node *L,int n,int m)//输出每次出列的人{int k;cout<<"请输入第一个报数人：";cin>>k;if(k<1||k>n){cout<<"请输入1-"<<n<<"之间的数"<<endl;} else{cout<<"\n出列顺序:\n";for(int i=1;i<n;i++){Node *q = new Node;if(i==1) q=DeleteList(&L,k+m-1,q);//第一个出列人的号数else q=DeleteList(&L,m,q);cout<<"号数："<<q->data<<endl;delete q;//释放出列人的存储空间}cout<<"最后一个出列号数是："<<L->data<<endl;;//输出最后出列人的号数}}Node *DeleteList(Node **L,int i,Node *q) //寻找每次出列的人{if(i==1) i+=LengthList(*L);//顺序依次出列情况的处理方式Node *p;p=*L;int j=0;while(j<i-2) {p=p->next;j++;}q = p->next;p->next=p->next->next;*L = p->next;return(q);}int LengthList(Node *L)//计算环上的人数{if(L){cout<<"尾指针错误!"<<endl;}//异常处理else{int i=1;Node *p=L->next;while(p!=L){i++;p=p->next;}return(i);}}复杂度分析：for(int i=1;i<=n;i++){Node *p;p=new Node;p->number=i;p->next=NULL;if(i==1) L=q=p;else{q->next=p;q=q->next;}时间复杂度：O（n）if(i==1) i+=LengthList(*L);Node *p;p=*L;int j=0;while(j<i-2) {p=p->next;j++;}q = p->next;p->next=p->next->next;*L = p->next;return(q);时间复杂度：O（n2）算法的空间复杂度：O（n2）4.界面设计5. 运行、测试与分析(二)采用顺序存储结构如何实现约瑟夫环问题代码和解释#include <stdlib.h>#include<stdio.h>#include<malloc.h>#define MaxSize 50typedef char ElemType;typedef struct Seqlist{//线性表顺序存储结构定义ElemType *elem[MaxSize];//存放顺序表数据元素int length;//当前长度}*JSeqlist;//线性表存储结构类型名JSeqlist Int_SeqList(void){//顺序表初始化JSeqlist L;L=(JSeqlist)malloc(sizeof(struct Seqlist));if(L!=NULL)L->length=0;elseprintf("超出范围！！");return L;}ElemType *Locate_SeqList(JSeqlist L,int p){//查找线性表中下标为P的元素if(p>=0&&L->length)return(L->elem[p]);else{printf("顺序表中不存在相关元素");return NULL;}}int Insert_SeqList(JSeqlist L,int i,ElemType *x){//在顺序表中指定元素前插入Xint j;if(L->length==MaxSize)//L.length是最后一个元素的位置{printf("线性表已满，无法进行插入操作！！！！\n");return 0;}if(i<0||i>L->length){printf("插入位置不对，超出顺序表长度\n");return 0;}if(i==0){L->elem[i]=x;L->length=L->length+1;return 1;}for(j=L->length;j>=i;j--){L->elem[j]=x;}L->length++;return 1;}int Delete_JSeqlist(JSeqlist L,int i){//在顺序表中删除第i个元素int j;if(i<0||i>L->length-1){printf("删除位置不对，超出顺序表的长度啦\n");return 0;}for(j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}void josephus(JSeqlist L,int start,int m){//josephus问题求解的非常牛逼的函数int s,i;ElemType *w;s=start-1;for(i=L->length;i>0;i--){s=(s+m-1)%i;w=Locate_SeqList(L,s);printf("出列人员为：%s\n",w);Delete_JSeqlist(L,s);}}int main (void){JSeqlist Josephus;int n,m,i,k,s;Josephus=Int_SeqList();//顺序表初始化printf(" 约瑟夫环问题顺序表求解_愚人节特别版\n\n");printf("请输入本问题中总人数m=");scanf("%d",&n);printf("请输入本问题开始人员的位置S=");scanf("%d",&s);printf("请输入本问题的计数值m=");scanf("%d",&m);printf("请输入本问题中这些人的名字\n");for(i=0;i<n;i++){printf("第%d位置的人员的名字为:",(i+1));Josephus->elem[i]=(ElemType *)calloc(10,sizeof(char));scanf("%s",Josephus->elem[i]);k=Insert_SeqList(Josephus,i,Josephus->elem[i]);if(k==0)exit(1);}josephus(Josephus,s,m);free(Josephus);getchar();return 0;}运行结果(三)密码不同#include <iostream.h>struct CList{int password;int number;struct CList *next;};typedef struct CList CNode;typedef CNode *CLink;CLink CreateList(int length){CLink head;CLink before;CLink new_node;int i;head=new CNode;if(head==NULL)return NULL;cout << "Please Input Password 1 :" << endl;cin >> head->password;head->number=1;head->next=NULL;before=head;for(i=1;i<length;i++){new_node=new CNode;if(new_node == NULL)return NULL;new_node->number = i+1;cout << "Please Input Password " << new_node->number << ":" <<endl;cin >> new_node->password;new_node->next = NULL;before->next=new_node;before=new_node;}new_node->next =head;return head;}int main(){CLink head;CLink ptr,back,last;int i,j,m,n;cout << "Please Input the Number of Persons: " << endl;cin >> n;cout << "Please Input the First Password M: " << endl;cin >> m;head=CreateList(n);ptr=head;for(i=0;i<n;i++){for(j=0;j<m-1;j++){back=ptr;//定位最后一个数的接点赋值给backptr=back->next;}cout <<"第"<<i+1<<"个出列的编号为:"<<ptr->number<<endl;m=ptr->password;if(ptr==head){last=head;while(last->next!=head)last=last->next;last->next=head->next;delete ptr;ptr=last->next;head=ptr;}else{back->next=ptr->next;delete ptr;ptr=back->next;}}return 0;}运行结果（三）心得体会：1.编程是个很细致的工作，尤其是在写顺序表的时候，涉及的函数很多，函数名中最初为了看在清晰，涉及成单词首字母是大写的，但是后来在函数调用的时候，就忘记了最初命名的时候是大写的了，导致编译的时候不能识别。

约瑟夫环问题知识点总结

约瑟夫环问题知识点总结约瑟夫环问题的描述如下：有n个人（编号从1到n），他们围成一个环形。

从第一个人开始报数，数到m的人被杀掉，然后从被杀掉的人的下一个人开始重新报数，直到所有人都被杀掉为止。

问题的解是最后剩下的那个人的编号。

约瑟夫环问题在计算机科学和数学领域都有着广泛的应用，因为它涉及到循环队列、递归、数学归纳法等多个概念。

以下是约瑟夫环问题的一些重要知识点总结：1. 约瑟夫环问题的递归解法递归是解决约瑟夫环问题的一种常见的方法。

基本思路是将问题分解为规模更小的子问题，并通过解决子问题来解决原始问题。

对于约瑟夫环问题来说，递归的解法是通过递归地计算每轮的幸存者，直到只剩下一个人为止。

递归解法的关键是找到问题的递归关系。

具体而言，对于约瑟夫环问题，如果用f(n, m)表示n个人中最后幸存者的编号，那么可以得出如下的递归关系：f(n, m) = (f(n-1, m) + m) % n其中，%表示取模运算。

该递归关系表明，当有n个人的时候，最后幸存者的编号可以通过n-1个人的最后幸存者的编号计算得到。

2. 约瑟夫环问题的迭代解法除了递归解法之外，约瑟夫环问题还可以通过迭代的方式进行求解。

迭代解法的基本思路是模拟报数和杀人的过程，直到最后只剩下一个人为止。

迭代解法的关键是找到每一轮报数的规律。

具体而言，对于约瑟夫环问题，可以用一个循环队列来模拟报数的过程，每次报数到第m个人就将其从队列中移除。

通过不断循环这个过程，最终可以得到最后幸存者的编号。

3. 约瑟夫环问题的数学解法约瑟夫环问题还可以通过数学的方法进行求解。

具体而言，可以利用数学归纳法来推导出约瑟夫环问题的解析表达式。

这种方法的优点是可以更快地得到结果，但是需要一定的数学推导能力。

通过数学推导，可以得到约瑟夫环问题的解析表达式：f(n, m) = (f(n-1, m) + m) % n其中，f(1, m) = 0。

该表达式可以直接求解出最后幸存者的编号。

有关经典约瑟夫问题的四种解法

有关经典约瑟夫问题的四种解法约瑟夫问题是信息学奥赛中的⼀类经典且重要的题型，在平常的测试中屡屡出现。

通常题设可抽象为：⼀开始有n个⼈围成⼀个圈，从 1开始顺时针报数，报出m的⼈被踢出游戏.。

然后下⼀个⼈再从1开始报数，直到只剩下⼀个⼈。

　或者：曾经有个⼈在他⾝边，然⽽现在只剩他⼀个⼈。

Who are you? Who am I? Why am I here?⾛的越来越慢，⼈越来越少，可终于还是只剩⼀个了呢。

他们围成⼀圈，随机了⼀个⼈作为1号，然后逆时针依次编号。

1号开始报数，报到 1，他⾛了；然后2号开始报数，2号报了1，3 号报了2 ，于是3 号也⾛了……每⼀轮都从上⼀次出局的下⼀个⼈开始报数，第i轮从1 报到i，报i的⼈出局。

直到只剩他⼀个⼈。

却早已不记得他⾃⼰是谁。

针对不同的数据范围，可以存在如下⼏种做法：1. O(nm) O(nm)的复杂度适⽤于n,m都在30000以内的情况，此类题型较少，例如“约瑟夫游戏”⼀题，n,m<=30000，由于随着游戏的不断进⾏，需要枚举的⼈数越少，所以复杂度实际低于O(nm)。

算法思路：暴⼒模拟即可。

#include<bits/stdc++.h>using namespace std;int T,N,M; bool v[1000100];void wk(){memset(v,0,sizeof(v));scanf("%d%d",&N,&M);int t=0,num=0,pos=1;while(1){if(v[pos]){++pos;if(pos==N+1) pos=1;continue;}++num;if(num==M){if(t==N-1){printf("%d\n",pos);return;}v[pos]=1,++t,num=0;}++pos;if(pos==N+1) pos=1;}}int main(){scanf("%d",&T);while(T--) wk();return 0;}暴⼒模拟约瑟夫问题2.O(n) O(n)算法已经适⽤于⼤多数约瑟夫问题，让n<=1e7的数据范围可以被轻松解决，考虑以任意⼀⼈为起点，选出第m个⼈后的编号变化，设起始id==0，选出第m个⼈后，id−>(id+m)，再回归到原来的圆形，设i表⽰第i轮游戏，那么整体的公式即为(id+m)%(n−i+1)。

约瑟夫问题实验报告

约瑟夫问题实验报告（文章一）：约瑟夫问题数据结构实验报告中南民族大学管理学院学生实验报告实验项目: 约瑟夫问题课程名称：数据结构年级：专业：信息管理与信息系统指导教师：实验地点：管理学院综合实验室完成日期：小组成员：学年度第（一）、实验目的（1）掌握线性表表示和实现；（2）学会定义抽象数据类型；（3）学会分析问题，设计适当的解决方案；（二）、实验内容【问题描述】：编号为1,2,…,n 的n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。

一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自 1 开始顺序报数，报到m 时停止报数。

报m 的人出列，将他的密码作为新的m 值，从他在顺时针方向上的下一个人开始重新从1 报数，如此下去，直至所有人全部出列为止。

试设计一个程序求出出列顺序。

【基本要求】：利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

【测试数据】：m 的初值为20；密码：3，1，7，2，4，8，4（正确的结果应为6，1，4，7，2，3，5）。

（三）、实验步骤（一）需求分析对于这个程序来说，首先要确定构造链表时所用的方法。

当数到m 时一个人就出列，也即删除这个节点，同时建立这个节点的前节点与后节点的联系。

由于是循环计数，所以才采用循环列表这个线性表方式。

程序存储结构利用单循环链表存储结构存储约瑟夫数据（即n个人的编码等），模拟约瑟夫的显示过程，按照出列的顺序显示个人的标号。

编号为1,2,?,n 的n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。

一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1 开始顺序报数，报到m 时停止报数。

报m 的人出列，将他的密码作为新的m 值，从他在顺时针方向上的下一个人开始重新从1 报数，如此下去，直至所有人全部出列为止。

试设计一个程序求出出列顺序。

基本要求是利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

NOIP算法：约瑟夫问题(C++)

约瑟夫问题也称为约瑟夫斯置换,在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。

一、一般形式1.N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。

例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。

2.有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1开始报数。

就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。

算法思路：模拟（1）由于对于每个人只有在与不在环中两种状态（2）开始时每个人都在环中（3）模拟过程，直到环中只剩下一人。

方法一：设立标记，每个元素标记为出队或在队中/ch0302/1748/#include<iostream>#include<algorithm>#include<cstring>#include<cstdio>using namespace std;const int maxn=310;int a[maxn];int main(){int p,num,cnt,n,m,tmp;while(scanf("%d%d",&n,&m)!=EOF&&(n!=0||m!=0)){memset(a,0,sizeof(a));p=1;for(num=1;num<=n;num++){//一共要数n轮for(cnt=1;cnt<=m;cnt++){//每一轮数到mwhile(a[p]==1)p=p%n+1;//如果指针所指已有标记指针后移tmp=p;//此时p指向环中的第cnt只猴子p=p%n+1;//指针后移}a[tmp]=1; //将第m只猴子标记}printf("%d\n",tmp);//第n轮的第m只猴子就是解}return 0;}方法二：使用数组模拟链表codevs1282 约瑟夫问题/problem/1282/#include<iostream>#include<algorithm>#include<cstring>#include<cstdio>#include<vector>using namespace std;const int maxn=30050;int a[maxn];int main(){int n,m,i,j,p;scanf("%d%d",&n,&m);for(i=1;i<n;i++)a[i]=i+1;a[n]=1;p=n;for(i=1;i<=n;i++){for(j=1;j<m;j++)p=a[p];printf("%d ",a[p]);a[p]=a[a[p]];}return 0;}二、深入探讨对于约瑟夫问题，若需要依次记录退出编号的情况：优化方法是使用线段树维护区间和，并进行单点更新。

约瑟夫问题(算法与数据结构课设报告)

线性表的操作及其应用一、问题描述线性表、队列是一种常用的数据结构，有顺序和链式两种存储结构，在实际中应用十分广泛，而链表又分为单链表和循环链表，队列又分为链式队列和循环队列。

这些数据结构都可用来解决约瑟夫环问题。

约瑟夫环问题是算法设计中的一个经典问题，是顺序编号的一组n个人围坐一圈，从第1个人按一定方向顺序报数，在报到m时该人出列，然后按相同方法继续报数，直到所有人出列。

设计算法求约瑟夫环中人员的出列顺序。

二、基本要求1、选择合适的存储结构，建立线性表；2、利用顺序存储结构求解约瑟夫环问题；3、利用单链表和循环链表分别求解约瑟夫环问题；4、利用队列求解约瑟夫环问题。

三、测试数据约瑟夫环的测试数据为7，报数为1至3。

四、算法思想由于用到四种不同的存储结构，它们的算法思想依次是：1、首先建立一个顺序表模拟整个约瑟夫环，手动输入顺序表长（即参加约瑟夫循环的人数）和循环的次数和表元素。

用已经输出总人数和顺序表长作比较，作为外层循环条件。

并对每一个输出后的元素重新赋值以为标记。

对于每次循环，首先检查顺序表此次是不是我们设立的标记，如果不是则循环次数加1，当达到要求的循环次数时就将循环次数设置为0，输出该元素到屏幕并将总输出元素加1。

每次外循环我们都会移到表的下一个位置，作为新的判断条件，每次报到表尾的时候，我们都将重新设置到表尾，作为下次循环的表元素。

2、首先采用链式循环链表建立整个约瑟夫环，手动输入第一次的循环次数和每个人所持下一个循环次数。

设立判断指针指向表头，并将该指针是否为空作为外层循环条件。

做一个内层循环，将判断指针移动到循环要输出的数，并设立一个前指针指向该指针的前一个位置，输出该元素后，将循环次数重新赋值成该元素。

接着判断前指针和判断指针比较，如果相等说明整个表已经输出完毕，否则将删除该位置的元素。

3、用链式队列建立循环约瑟夫环，手动输入人数，第一次的循环次数和每个人所持下一个循环次数。

并将每一个元素依次入队列，根据第一次循环次数，建立一个for循环，每一次循环都出队列，如果达到要求的循环次数就输出，否则进队列，这样这个数字就出现在队尾。

约瑟夫环问题实验报告完整版

struct Node
{
int data;//数据域
Node *next;//next指针指向下一个结点
};
3.算法设计
问题要求建立模型，确定存储结构，之后对任意n个人，密码为m，实现约瑟夫环问题，出圈的顺序可以依次输出，也可以用一个数组存储。
设计流程图如图1.1所示。
图1.1设计流程图
（1）创建循环链表
{
p=p->next;
}
q=p->next;
p->next=q->next;
p=p->next;
printf("第%3d个出圈的人是：%3d\n",i,q->value);
free(q);
}
scanf("\n");
p->next=NULL;
}
（3）主程序执行
主程序运行，调用函数，程序接受数据后，输出出圈列数。
}
（2）约瑟夫环报数的算法在运行为循环方式，报数者除非本身已经出去，否则继续顺序报数，其报数循环的代码为
void Joseph(NODE *p,int number,int n)
{
int i,j;
NODE *q=NULL;
for(i=1; i<=number; i++)
{
for(j=1; j<n-1; j++)
由于内容的要求以及问题的方便，用循环链表作为本次实验的抽象数据类型。申请一个结点作为第一个结点，之后调用creat_list函数将后续结点一次插入链接，构造为循环链表。
NODE *link(int number)
{
NODE *head=NULL,*p=NULL,*q=NULL;

Josephu约瑟夫问题java实现（环形链表）

Josephu约瑟夫问题java实现（环形链表）5.4.1约瑟夫问题Josephu(约瑟夫、约瑟夫环) 问题为：设编号为 1，2，… n 的 n 个⼈围坐⼀圈，约定编号为 k（1<=k<=n）的⼈从 1 开始报数，数到 m 的那个⼈出列，它的下⼀位⼜从 1 开始报数，数到 m 的那个⼈⼜出列，依次类推，直到所有⼈出列为⽌，由此产⽣⼀个出队编号的序列。

5.4.2解决思路⽤⼀个不带头结点的循环链表来处理 Josephu 问题：先构成⼀个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下⼀个结点⼜从 1 开始计数，直到最后⼀个尚硅⾕ Java 数据结构和算法更多 Java –⼤数据 –前端 –python ⼈⼯智能 -区块链资料下载，可访问百度：尚硅⾕官⽹第 55页结点从链表中删除算法结束。

代码实现//约瑟夫问题-环形链表public class Josepfu {public static void main(String[] args) {CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();circleSingleLinkedList.addBoy(5);// 加⼊ 5 个⼩孩节点circleSingleLinkedList.showBoy();circleSingleLinkedList.countBoy(1, 2, 5);}}//环形链表class CircleSingleLinkedList{//指向链表的第⼀个节点private Boy first = null;//添加num个⼩孩节点public void addBoy(int num){if (num<1)throw new RuntimeException("输⼊值错误");Boy curBoy = null;for(int i=1;i<=num;i++){Boy boy = new Boy(i);if (i==1){first = boy;first.setNext(first);//形成环curBoy = first;}else{boy.setNext(first);curBoy.setNext(boy);curBoy = boy;}}}// 根据⽤户的输⼊，计算出⼩孩出圈的顺序/**** @param startNo* 表⽰从第⼏个⼩孩开始数数* @param countNum* 表⽰数⼏下* @param nums* 表⽰最初有多少⼩孩在圈中*/public void countBoy(int startNo, int countNum, int nums) {if (nums<1||countNum<1||first==null||startNo<1||startNo>nums)throw new RuntimeException("参数有误，从新输⼊！！");//创建辅助指针，指向环形链表的最后⼀个节点Boy helper = first;while (helper.getNext()!=first){helper = helper.getNext();}//移动helper和first，使从第startNo个⼩孩开始数for (int i=0;i<(startNo-1);i++){helper = helper.getNext();first = first.getNext();}//开始数数，出圈while (helper!=first){//报数for (int i=0;i<(countNum-1);i++){helper = helper.getNext();first = first.getNext();}System.out.println("⼩孩"+ first.getNo() +"出队列：" );first = first.getNext();helper.setNext(first);}System.out.println("最后的⼩孩："+ first.getNo());}//遍历环形链表public void showBoy(){if (first==null)throw new RuntimeException("链表为空");System.out.println("⼩孩的编号： "+first.getNo());//first⽆法移动，创建中介节点遍历链表Boy curBoy = first.getNext();//当中介节点再⼀次回到first时，表⽰链表遍历完成while (curBoy!=first){System.out.println("⼩孩的编号： "+curBoy.getNo()); curBoy = curBoy.getNext();}}}//创建boy类表⽰⼀个节点class Boy{private int no;private Boy next;public Boy(int no) {this.no = no;}public int getNo() {return no;}public void setNo(int no) {this.no = no;}public Boy getNext() {return next;}public void setNext(Boy next) {this.next = next;}}。

用顺序表解决约瑟夫环问题

⽤顺序表解决约瑟夫环问题⼀、实验题⽬：约瑟夫环问题：设编号为1，2，3，……，n的n(n>0)个⼈按顺时针⽅向围坐⼀圈，m为任意⼀个正整数。

从第⼀个⼈开始顺时针⽅向⾃1起顺序报数，报到m时停⽌并且报m的⼈出列，再从他的下⼀个⼈开始重新从1报数，报到m时停⽌并且报m的⼈出列。

如此下去，直到所有⼈全部出列为⽌。

要求设计⼀个程序模拟此过程，对任意给定的m和n，求出出列编号序列。

实验要求：⽤顺序表实现。

⼆、设计分析：⾸先创建了⼀个顺序表，并且⽤数组存每个⼈的编号，出列的时候将此编号置为0，代表此位置的⼈已经出列，循环查询编号不为0的元素，并⽤变量j记下当前是第⼏个⼈，当j==m的时候，代表此位置是第m个⼈，输出并将编号置为0，⽤k记录出列⼈的下⼀位的索引，并将数组长度-1，再进⾏新⼀轮的循环，直到所有⼈都出列。

三、程序代码：#include<iostream>#include<cstdlib>using namespace std;const int MaxSize=100;typedef struct Node{int data[MaxSize];int length;}List;void CreateList(List *&L,int n){L=(List *)malloc(sizeof(List*));for(int i=1;i<=n;i++){L->data[i]=i;}L->length=n;}void DispList(List *&L,int m){int len=L->length;int j=0,k=1;while(L->length){for(int i=1;i<=len;i++){if(L->data[k]){j++;}if(j==m){cout<<L->data[k]<<" ";L->data[k]=0;L->length--;j=0;k=(k+1)%(len+1)?(k+1)%(len+1):1;break;}k=(k+1)%(len+1)?(k+1)%(len+1):1;}}}int main(){int m,n;cin>>m>>n;List *L;CreateList(L,n);DispList(L,m);return 0;}。

约瑟夫问题—顺序表完美实现