单链表实现约瑟夫问题
C语言用循环单链表实现约瑟夫环
C语⾔⽤循环单链表实现约瑟夫环⽤循环单链表实现约瑟夫环（c语⾔），供⼤家参考，具体内容如下源代码如下，采⽤Dev编译通过，成功运⾏，默认数到三出局。
主函数：main.c⽂件#include <stdio.h>#include "head.h"#include "1.h"int main(){Linklist L;int n;printf("请输⼊约瑟夫环中的⼈数：");scanf("%d",&n);Createlist(L,n);printf("创建的约瑟夫环为：\n");Listtrave(L,n);printf("依次出局的结果为：\n");Solution(L,n);return 0;}head.h⽂件：#include "1.h"#include <stdio.h>#include <stdlib.h>typedef int Elemtype;typedef struct LNode{Elemtype data;struct LNode *next;}LNode,*Linklist;void Createlist(Linklist &L,int n){Linklist p,tail;L = (Linklist)malloc(sizeof(LNode));L->next = L;//先使其循环p = L;p->data = 1;//创建⾸节点之后就先给⾸节点赋值，使得后⾯节点赋值的操作能够循环tail = L;for(int i = 2;i <= n;i++){p = (Linklist)malloc(sizeof(LNode));p->data = i;p->next = L;tail->next = p;tail = p;}printf("已⽣成⼀个长度为%d的约瑟夫环！\n",n);}void Listtrave(Linklist L,int n)//遍历函数{Linklist p;p = L;for(int i = 1;i <= n;i++){printf("%3d",p->data);p = p->next;}printf("\n");}int Solution(Linklist L,int n){Linklist p,s;p = L,s = L;int count = 1;while(L){if(count != 3){count++;p = p->next;//进⾏不等于3时的移位}else{Linklist q;q = p;//⽤q保存p所指的位置，⽅便进⾏节点的删除if(s->next->data == s->data)//当只有⼀个元素的时候{printf("%3d\n",s->data);free(s);return OK;}else//当有两个及两个以上的元素的时候{count = 1;//先将count重置为1printf("%3d",p->data);//再打印出出局的值while(s->next != p){s = s->next;//将s移位到p的前驱节点处}p = p->next;//使p指向⾃⼰的下⼀个节点s->next = p;//进⾏删除free(q);}}}}1.h⽂件：#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2运⾏结果：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
实验一约瑟夫环问题实验报告
题目二约瑟夫环问题设编号为1，2，3，……，n 的n(n>0)个人按顺时针方向围坐一圈，每个人持有一个正整数密码。
开始时任选一个正整数做为报数上限m ，从第一个人开始顺时针方向自1起顺序报数，起顺序报数，报到报到m 时停止报数，时停止报数，报报m 的人出列，的人出列，将他的密码作为将他的密码作为新的m 值，从他的下一个人开始重新从1报数。
报数。
如此下去，如此下去，如此下去，直到所有人全部出列直到所有人全部出列为止。
令n 最大值取30。
要求设计一个程序模拟此过程，求出出列编号序列。
struct node //结点结构{ int number; /* 人的序号人的序号*/ int cipher; /* 密码密码*/ struct node *next; /* 指向下一个节点的指针*/ }; 一、循环链表的结点类型定义/* 单链表的结点类型 */typedefstruct node{int number;int cipher;struct node *next;}list, *linklist;二、循环链表的初始化/* 函数功能:初始化n 个元素的循环链表参数;链表(linklist L)，元素个数（int n ）通过后插法对无头结点的链表初始化。
*/voidinit(linklist&L,int n){int key, i;cout<<"输入第1个人的密码为：";//输入第一个节点的密码。
cin>>key;L= new list;L->number = 1;L->cipher = key;L->next = L;for(i = 2; i<= n; i ++)//输入2—n 的节点密码。
{linklist p = new list;cout<<"输入第"<<i<<"个人的密码为：";cin>>key;p->cipher = key;p->number = i;p->next = L->next; //使用后插法插入。
从第s(sn)个人开始报数,数到m的人出圈;再由下一个人
1．约瑟夫问题：n个人围成一圈，从第s（s<n）个人开始报数，数到m的人出圈；再由下一个人开始报数，数到m的人出圈；……。
输出依次出圈的人的编号。
m的值预先选定，n由键盘输入。
分析：我们将这n个人组成一个链表，表中每一个元素为一记录类型，第一个域变量lvalue为人的编号，第二个域变量next指向下一个人，这样链接下去构成一个环形链。
然后由lvalue值为s的记录开始，对链中的元素逐一记数，数到第m个记录时，将它删去，即把第（m-1）个记录的指针改成指向第（m+1）个记录，然后从第（m+1）个向下记数，这样重复进行下去，直到剩下一个记录。
出列的人也组成一条链，r是其首指针，只要打印这条链就得到结果。
源程序如下：#include <iostream.h>#include <stdio.h>#include <stdlib.h> // 使用malloc()函数的库函数#include <malloc.h>typedef struct linknode{int lvalue;struct linknode *next;} point;int main(){int n,m,s,node,i;point *p,*q,*r;cout<<"Input total number, initial number and distance: ";cin>>n>>s>>m;p=(point *)malloc(sizeof(point));q=p;for(i=1; i<=n-1; i++){ // 生成链表q->lvalue=s;s=s%n+1;q->next=(point *)malloc(sizeof(point));q=q->next;}q->lvalue=s;q->next=p; // 生成循环链表node=n;r=(point *)malloc(sizeof(point));q=r;while(node>1){if(m==1){r->next=p;node=1;}else{for(i=1; i<=m-2; i++)p=p->next;q->next=p->next; // 将数到m的人出圈，链到出列人的链表中q=q->next;p->next=p->next->next;p=p->next;node--;}}for(i=1; i<=n-1; i++){ // 依次打印出列人的序号r=r->next;cout<<"The"<<i<<"th person is number:"<<r->lvalue<<endl;}if(m==1)cout<<"The last one is number:"<<r->next->lvalue<<endl;elsecout<<"The last one is number:"<<p->lvalue<<endl;return 1;}2．设单链表中存放着n个字符，试设计算法判断字符串是否中心对称。
约瑟夫问题
一问题描述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的值再输入每个人的密码最后得到出列顺序八附录（源程序）这里附上两种源程序，本质上相同，只是第一个程序按老师要求写为很多子函数形式，第二个是我已开始编的，一个大函数。
C++单链表实现约瑟夫环
#include <iostream.h>#include <stdlib.h>struct Member//定义结构体{int number;int password;Member *next;};class Joseph{public:Member *frist;//头指针int size;Joseph(void);~Joseph(void);int Size(void) const;//返回长度Member *Index(int i);//定位void Create(int i);//构造循环单链表int Delete(int i);//删除结点并返回number的值};Joseph::Joseph(){//frist=new Member;Member *p=new Member;frist=p;size=0;}Member *Joseph::Index(int i){if(i==0)return frist;Member *p=frist->next;int j=1;while(j<i){p=p->next;j++;}return p;}int Joseph::Size(void)const{return size;}void Joseph::Create(int i){for(int j=1;j<=i;j++){Member *p=Index(j-1);Member *q=new Member;q->number=j;p->next=q;size++;};//Member *p=Index(i);//p->next=frist;}Joseph::~Joseph(void){Member *p,*q;p=frist;while(size!=0){q=p;p=p->next;delete q;size--;}size=0;frist=NULL;}int Joseph::Delete(int i){Member *s,*p=Index(i-1);s=p->next;p->next=p->next->next;int x=s->number;cout<<x<<" ";int y=s->password;delete s;size--;return y;}void main(void){Joseph jos;int i;cout<<"Please input number of people :"<<endl;cin>>i;jos.Create(i);int frist;//设初始值cout<<"Please input the frist number :"<<endl;cin>>frist;for(int k=1;k<=i;k++)//用循环输入每个人的密码{cout<<"please input No."<<k<<"`s password:"<<endl;Member *b=jos.Index(k);cin>>b->password;}cout<<"The final is :"<<endl;int l=frist%i;if (l==0) l=i;for(int b=i-1;b>0;b--){frist=jos.Delete(l);l=(frist+l-1)%b;int e=jos.Size();if(l==0)l=e;}jos.Delete(l);cout<<endl;}。
实验一：约瑟夫问题
实验一：约瑟夫问题问题描述：用数组和链表存储方式实现约瑟夫问题。
约瑟夫问题：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开始报数。
通过循环单链表可以很方便地模拟这个过程。
模板约瑟夫环(Joseph)问题.ppt
最新 文档
10
4.详细设计
main()函数
Joseph()函数
从循环链表中按初始密码 依次找出对应出列序列
输出每个人持有的密码c
所有密码c输出后，删除相应 的节点，并释放所占的存储
空间
图5 输出序列的实现
最新 文档
11
5.测试报告
//尾插入法创建链表
void CreateLinkList(LinkList *&L,int n)
最新 文档
3
2.问题描述
编号是1，2，……,n的n个人按照顺时针方向围 坐一圈，每个人只有一个密码（正整数）。一 开始任选一个正整数作为报数上限值m,从第一 个人开始顺时针方向自1开始顺序报数，报到m 时停止报数。报m的人出列，将他的密码作为 新的m值，从他在顺时针方向的下一个人开始 重新从1报数，如此下去，直到所有人全部出 列为止。设计一个程序来求出出列顺序。
int i = 1;
c = L;
printf("输出出对序列:");
while (n)
{
while (i != m)
{
s = c;
c = c->next;
i++;
}
printf("%-3d",c->data);
m = c->cipher;
s->next = c->next;
free(c);
c = s->next;
8 这就是第三步的位置， 这时他的密码作为新的 m值，即m=9，同时得 到的第二个密码为9；9 号出去向下走9，到这 儿；继续走就行了（这 儿剩余的就是：1，2，
3，5，6，7，8，9）
C语言的循环链表和约瑟夫环
C语言的循环链表和约瑟夫环C语言的循环链表和约瑟夫环约瑟夫问题）是一个数学的应用问题，对于学习C语言四非常挺有帮助的，下面是店铺为大家搜集整理出来的有关于C语言的循环链表和约瑟夫环，一起了解下吧!循环链表的实现单链表只有向后结点，当单链表的尾链表不指向NULL，而是指向头结点时候，形成了一个环，成为单循环链表，简称循环链表。
当它是空表，向后结点就只想了自己，这也是它与单链表的主要差异，判断node->next是否等于head。
代码实现分为四部分：1. 初始化2. 插入3. 删除4. 定位寻找代码实现：1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1void ListInit(Node *pNode){int item;Node *temp,*target;cout<<"输入0完成初始化"<<endl; cin="">>item;if(!item)return ;if(!(pNode)){ //当空表的时候，head==NULLpNode = new Node ;if(!(pNode))exit(0);//未成功申请pNode->data = item;pNode->next = pNode;}else{//for(target = pNode;target->next!=pNode;target = target->next);4 15 16 17 18 19 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 3 0 3 1 3 2 3 3 3 4 3 5 3temp = new Node;if(!(temp))exit(0);temp->data = item;temp->next = pNode;target->next = temp;}}}void ListInsert(Node *pNode,int i){ //参数是首节点和插入位置Node *temp;Node *target;int item;cout<<"输入您要插入的值:"<<endl; cin="">>item;if(i==1){temp = new Node;if(!temp)exit(0);temp->data = item;for(target=pNode;target->next != pNode;target = target->next);temp->next = pNode;target->next = temp;pNode = temp;}else{target = pNode;for (int j=1;j<i-1;++j) target="target-">next;temp = new Node;if(!temp)exit(0);temp->data = item;temp->next = target->next;target->next = temp;}}void ListDelete(Node *pNode,int i){Node *target,*temp;if(i==1){for(target=pNode;target->next!=pNode;target=target ->next);temp = pNode;//保存一下要删除的首节点 ,一会便于释放6 37 38 39 4 0 4 1 4 2 4 3 4 4 4 5 4 6 4 7 4 8 4 9 5 0 5 1 5 2 5 3 5 4 5 5 5 6 5 7 5pNode = pNode->next;target->next = pNode;temp;}else{target = pNode;for(int j=1;j<i-1;++j) target="target-">next;temp = target->next;//要释放的nodetarget->next = target->next->next;temp;}}int ListSearch(Node *pNode,int elem){ //查询并返回结点所在的位置Node *target;int i=1;for(target = pNode;target->data!=elem && target->next!= pNode;++i)target = target->next;if(target->next == pNode && target->data!=elem)return 0;else return i;}</i-1;++j)></i-1;++j)></endl;></endl;>5 96 0 6 1 6 2 6 3 6 4 6 5 6 6 67 68 69 7 0 7 1 7 2 7 3 7 4 7 5 7 6 7 7 7 8 7 9 8约瑟夫问题约瑟夫环(约瑟夫问题)是一个数学的'应用问题：已知n个人(以编号1，2，3…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报数，如此下去，直至所有人全部出列为止.试设计一个程序求出出列顺序.
约瑟夫环问题详解
约瑟夫环问题详解很久以前，有个叫Josephus的⽼头脑袋被门挤了，提出了这样⼀个奇葩的问题：已知n个⼈（以编号1，2，3...n分别表⽰）围坐在⼀张圆桌周围。
从编号为k的⼈开始报数，数到m的那个⼈出列；他的下⼀个⼈⼜从1开始报数，数到m的那个⼈⼜出列；依此规律重复下去，直到圆桌周围的⼈全部出列这就是著名的约瑟夫环问题，这个问题曾经风靡⼀时，今天我们就来探讨⼀下这个问题。
这个算法并不难，都是纯模拟就能实现的。
思路⼀：⽤两个数组，mark[10000]和num[10000],mark这个数组⽤来标记是否出队，num这个⽤来存值，然后每次到循环节点的时候就判断mark是否为0(未出队)，为0则输出num[i]，并标记mark[i]=1，直到所有的num都出队。
附上C++代码：#include<iostream>#include<cstring>#include<cstdio>#include<cstdlib>#include<cctype>#include<cmath>#include<algorithm>using namespace std;char num[1000];bool mark[1000];int main(){while(true){memset(mark,0,sizeof(mark));int n;int k,m;int i,j;int del=k-1;cin>>n>>k>>m;for(i=0;i<n;++i){cin>>num[i];}int cnt=n;for(i=cnt;i>1;--i){for(int j=1;j<=m;){del=(del+1)%n;if(mark[del]==0)j++;}cout<<num[del]<<" ";mark[del]=1;}for(i=0;i<n;++i){if(mark[i]==0)break;}cout<<endl<<"The final winner is:"<<num[i]<<endl;}return 0;}思路⼆：⽤⼀个数组就可，每次到了循环节点了就将num[i]输出，然后将后⾯的值往前移动⼀位，直到所有的节点出列。
约瑟夫问题实验报告
约瑟夫问题实验报告（文章一）：约瑟夫问题数据结构实验报告中南民族大学管理学院学生实验报告实验项目: 约瑟夫问题课程名称：数据结构年级：专业：信息管理与信息系统指导教师：实验地点：管理学院综合实验室完成日期：小组成员：学年度第（一）、实验目的（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 报数，如此下去，直至所有人全部出列为止。
试设计一个程序求出出列顺序。
基本要求是利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
数据结构实验报告-线性表
1 线性表1. 实验题目与环境1.1实验题目及要求（1）顺序表的操作利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。
（2）单链表的操作利用链式存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。
（3）线性表的应用约瑟夫环问题。
有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。
要求依次输出出列人的编码。
2.问题分析（1）顺序表的操作利用一位数组来描述顺序表，即将所有元素一词储存在数组的连续单元中，要在表头或中间插入一个新元素时，需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。
同理，删除开头或中间的元素时，则将其后的所有元素向前移动一个位置以填补空位。
查找元素时，则需要利用循环语句，一一判断直到找出所要查找的元素（或元素的位置），输出相关内容即可（2）单链表的操作利用若干个结点建立一个链表，每个节点有两个域，即存放元素的数据域和存放指向下一个结点的指针域。
设定一个头指针。
在带头结点的单链表中的第i个元素之前插入一新元素，需要计数找到第i-1个结点并由一指针p指向它，再造一个由一指针s指向的结点，数据为x，并使x的指针域指向第i个结点，最后修改第i-1个结点的指针域，指向x结点。
删除第i个元素时，需要计数寻找到第i个结点，并使指针p指向其前驱结点，然后删除第i个结点并释放被删除结点的空间。
查找第i个元素，需从第一个结点开始计数找到第i个结点，然后输出该结点的数据元素。
（3）线性表的应用程序运行之后，首先要求用户指定初始报数的上限值，可以n<=30,此题中循环链表可不设头结点，而且必须注意空表和"非空表"的界限。
题目约瑟夫（Joseph）问题的一种描述是编号为1,2,,
题目：约瑟夫（Joseph）问题的一种描述是：编号为1，2，......，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个开始重新从1报数，如此下去，直至年有人全部出列为止。
试设计一个程序求出出列顺序。
班级：姓名：学号：完成日期：一、需求分析1．本演示程序中，利用单向循环链表存储结构存储约瑟夫环数据（即n个人的编号和密码）。
2．演示程序以用户和计算机的对话方式执行，即在计算机终端上显示"提示信息"之后，由用户在键盘上输入演示程序中需要输入的数据，运算结果显示在其后。
3．程序执行的命令包括：1)构造单向循环链表；2）4．测试数据m 的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4，首先m值为6（正确的出列顺序为6，1，4，7，2，1，3，5）。
二、概要设计1．单向循环链表的抽象数据类型定义为：ADT List｛数据对象：D=｛ai | ai∈正整数，I=1，2，......，n,n≥0｝数据关系：R1=｛< ai-1，ai > |，ai-1，ai∈D,I=1，2，......，n｝基本操作：Init List(&L)操作结果：构造一个空的线性表L。
List Insert(&L,i,e)初始条件：线性表L已存在，1≤i≤List Length(L)+1.操作结果：在L中第i个位置之前插入新的数据无素e，L长度加1。
List Delete(&L,i,&e)初始条件：线性表L存在非空，1≤i≤List Length(L).操作结果：删除L的第i个元素，并用e返回其值，L长度减1。
2．程序包含四个模块：1）主程序模块：三详细设计typedef struct LNode{int password; //密码int No; //序号struct LNode *next; //下一成员指针}member; //成员结构体typedef int status;#define OVERFLOW -2#define OK 1#define ERROR 0#include <stdio.h>#include <stdlib.h>status CreateList_Circle(member **,int);status DeleteNode(member **);status main(){int n,m;member *head=NULL,*p=NULL; //头指针即首成员地址，遍历指针p printf ("Please enter number of people:\n");scanf ("%d",&n); //总成员数while (n<=0){printf ("n must be positive, please enter again:\n");scanf ("%d",&n);}if(!CreateList_Circle(&head,n)) //创建循环链表，返回头指针head return OVERFLOW;printf ("Please enter initial m:\n");scanf ("%d",&m); //初始mwhile (m<=0){printf ("m must be positive, please enter again:\n");scanf ("%d",&m);}printf ("\nThe order is:\n");p=head;while (n>=2) //寻找出列成员{int i;m=(m%n==0)?n:m%n; //化简m值for (i=1;i<m;i++)p=p->next; //p指向出列成员printf ("%d\n",p->No); //输出出列成员序号m=p->password; //修改mDeleteNode(&p); //删除链表中的出列成员n--; //成员数自减}printf ("%d\n",p->No); //输出最后一个成员序号return OK;}status CreateList_Circle(member **p_head,int n){//此算法创建一个无头结点的循环链表，结点数n,*p_head返回链表头指针即首结点地址int i;member *tail,*p;*p_head=(member *)malloc(sizeof(member));if (!(*p_head)) return OVERFLOW;(*p_head)->No=1; //储存成员一序号printf ("Please enter password of No. 1:\n");scanf ("%d",&(*p_head)->password); //储存成员一密码tail=*p_head;tail->next=NULL;for (i=2;i<n+1;i++){p=(member *)malloc(sizeof(member));if (!p) return OVERFLOW;p->No=i; //储存成员序号printf ("Please enter password of No. %d:\n",i);scanf("%d",&(p->password)); //储存成员密码tail->next=p;tail=p;}tail->next=*p_head;return OK;}status DeleteNode(member **pp){//此算法删除链表中的结点*pp,操作实质是将*pp下一结点复制到*pp后将其free member *temp;(*pp)->password=((*pp)->next)->password;(*pp)->No=((*pp)->next)->No;temp=(*pp)->next;(*pp)->next=(*pp)->next->next;free(temp);return OK;}四、调试分析程序的编写和调试基本正常。
线性表实验报告
LinkList p;
p=L->next;
while(p){
printf("%5d",p->data);
p=p->next;
}
return OK;
}
void main()
{
int i,n,k,d,e;
LinkList La,Lb;
InitList_L(La);
InitList_L(Lb);
e=L.elem[i];
for(j=i;j<=L.length;j++)
L.elem[j]=L.elem[j+1];
L.length--;
return ok;
}
int output(sqlist &L){
int i;
printf("output sqlist data:\n");
for(i=0;i<L.length;i++)
PrintList(La);
printf("\nAfter delete the list is:\n");
ListDelete_L(La,e);
PrintList(La);
printf("\n");
printf("I will insert:");
scanf("%d",&k);
ListInsert_L(La,k);
int a,j,i,m;
CLinkList p,r;
printf("Input the m(m<=20):\nm=");
scanf("%d",&m);
约瑟夫问题(算法与数据结构课设报告)
线性表的操作及其应用一、问题描述线性表、队列是一种常用的数据结构，有顺序和链式两种存储结构，在实际中应用十分广泛，而链表又分为单链表和循环链表，队列又分为链式队列和循环队列。
这些数据结构都可用来解决约瑟夫环问题。
约瑟夫环问题是算法设计中的一个经典问题，是顺序编号的一组n个人围坐一圈，从第1个人按一定方向顺序报数，在报到m时该人出列，然后按相同方法继续报数，直到所有人出列。
设计算法求约瑟夫环中人员的出列顺序。
二、基本要求1、选择合适的存储结构，建立线性表；2、利用顺序存储结构求解约瑟夫环问题；3、利用单链表和循环链表分别求解约瑟夫环问题；4、利用队列求解约瑟夫环问题。
三、测试数据约瑟夫环的测试数据为7，报数为1至3。
四、算法思想由于用到四种不同的存储结构，它们的算法思想依次是：1、首先建立一个顺序表模拟整个约瑟夫环，手动输入顺序表长（即参加约瑟夫循环的人数）和循环的次数和表元素。
用已经输出总人数和顺序表长作比较，作为外层循环条件。
并对每一个输出后的元素重新赋值以为标记。
对于每次循环，首先检查顺序表此次是不是我们设立的标记，如果不是则循环次数加1，当达到要求的循环次数时就将循环次数设置为0，输出该元素到屏幕并将总输出元素加1。
每次外循环我们都会移到表的下一个位置，作为新的判断条件，每次报到表尾的时候，我们都将重新设置到表尾，作为下次循环的表元素。
2、首先采用链式循环链表建立整个约瑟夫环，手动输入第一次的循环次数和每个人所持下一个循环次数。
设立判断指针指向表头，并将该指针是否为空作为外层循环条件。
做一个内层循环，将判断指针移动到循环要输出的数，并设立一个前指针指向该指针的前一个位置，输出该元素后，将循环次数重新赋值成该元素。
接着判断前指针和判断指针比较，如果相等说明整个表已经输出完毕，否则将删除该位置的元素。
3、用链式队列建立循环约瑟夫环，手动输入人数，第一次的循环次数和每个人所持下一个循环次数。
并将每一个元素依次入队列，根据第一次循环次数，建立一个for循环，每一次循环都出队列，如果达到要求的循环次数就输出，否则进队列，这样这个数字就出现在队尾。
约瑟夫环问题 实验报告完整版
{
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;
约瑟夫问题及变种
“约瑟夫”问题及若干变种例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)，对于极限数据会超时。
数据结构（C语言版）习题及答案第二章
数据结构（C语⾔版）习题及答案第⼆章习题2.1选择题1、线性表的顺序存储结构是⼀种（A）的存储结构，线性表的链式存储结构是⼀种（B）的存储结构。
A、随机存取B、顺序存取C、索引存取D、散列存取2、对于⼀个线性，既要求能够进⾏较快的插⼊和删除，⼜要求存储结构能够反映数据元素之间的逻辑关系，则应该选择（B）。
A、顺序存储⽅式B、链式存储⽅式C、散列存储⽅式D、索引存储⽅式3、已知，L是⼀个不带头结点的单链表，p指向其中的⼀个结点，选择合适的语句实现在p结点的后⾯插⼊s结点的操作（B）。
A、p->next=s ; s->next=p->next ;B、s->next=p->next ; p->next=s ;C、p->next=s ; s->next=p ;D、s->next=p ; p->next=s ;4、单链表中各结点之间的地址（ C D）。
A、必须连续B、部分地址必须连续C、不⼀定连续D、连续与否都可以5、在⼀个长度为n的顺序表中向第i个元素（0A、n-iB、n-i+1C、n-i-1D、i2.2填空题1、顺序存储的长度为n的线性表，在任何位置上插⼊和删除操作的时间复杂度基本上都⼀样。
插⼊⼀个元素⼤约移动表中的（n/2）个元素，删除⼀个元素时⼤约移动表中的（(n-1)/2）个元素。
2、在线性表的顺序存储⽅式中，元素之间的逻辑关系是通过（物理顺序）来体现的；在链式存储⽅式，元素之间的逻辑关系是通过（指针）体现的。
3、对于⼀个长度为n的单链表，在已知的p结点后⾯插⼊⼀个新结点的时间复杂度为（o(1)），在p结点之前插⼊⼀个新结点的时间复杂度为（o(n)），在给定值为e的结点之后插⼊⼀个新结点的时间复杂度为（o(n)）。
4、在双向链表中，每个结点包含两个指针域，⼀个指向（前驱）结点，另⼀个指向（后继）结点。
5、对于循环链表来讲，逐个访问各个结点的结束判断条件是（设P为指向结点的指针，L为链表的头指针，则p->next= =L）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
单链表解决约瑟夫问题
代码实现：
#include<stdio.h>
#include<stdlib.h>
typedef int DataType;
typedef struct Node
{
DataType data;
struct Node *next;
}ListNode, *LinkList;
LinkList CreateCycList(int n){
LinkList head = NULL;
ListNode *s, *r;
int i;
for (i = 1; i <= n; i++)
{
s = (ListNode*)malloc(sizeof(ListNode));
s->data = i;
s->next = NULL;
if (head == NULL)
head = s;
else
r->next = s;
r = s;
}
r->next = head;
return head;
}
void DisplayCycList(LinkList head){
ListNode *p;
p = head;
if (p == NULL)
{
printf("该链表是空表");
return;
}
while (p->next != head)
{
printf("%2d", p->data);
p = p->next;
}
printf("%2d\n", p->data);
}
void Josephus(LinkList head, int n, int m, int k) {
ListNode *p, *q;
int i;
p = head;
for (i = 1; i<k; i++)
{
q = p;
p = p->next;
}
while (p->next != p)
{
for (i = 1; i<m; i++)
{
q = p;
p = p->next;
}
q->next = p->next;
printf("%2d", p->data);
free(p);
p = q->next;
}
printf("%2d\n", p->data);
}
void main(){
LinkList h;
int n, k, m;
printf("输入环中人的个数，n=");
scanf("%d", &n);
printf("输入开始报数的序号，k=");
scanf("%d", &k);
printf("报数为m的人出列，m=");
scanf("%d", &m);
h = CreateCycList(n);
Josephus(h, n, m, k);
}。