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

合集下载

约瑟夫问题

一问题描述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的值再输入每个人的密码最后得到出列顺序八附录（源程序）这里附上两种源程序，本质上相同，只是第一个程序按老师要求写为很多子函数形式，第二个是我已开始编的，一个大函数。

实验报告——约瑟夫环

《数据结构》课程设计报告课程名称：《数据结构》课程设计课程设计题目：约瑟夫环姓名：张光栋院系：计算机学院专业：网络工程年级：2013级学号：13055532指导教师：张纪林一、需求分析1.以单项循环链表存储结构模拟约瑟夫环问题。

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

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

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

按出列顺序印出各人的编号。

2.演示程序以用户与计算机的对话方式执行，用户输入相应的数据，输出结果显示在其后。

3.测试数据：(1)n=55个人的密码依次为：2,4,2,6,2；首先m值为2（正确的输出顺序为：2 1 4 3 5）(2)n=77个人的密码依次为：2,4,1,4,3,2,3首先m值为5（正确的输出顺序为：5 1 3 4 6 2 7）二、概要设计为实现上述程序功能，可利用单向循环链表存储结构模拟此过程。

1.单向循环链表的抽象数据类型定义为：ADT CircularList{数据对象：D={ai|ai∈LNode,i=1,2,…,n,n≥0}数据关系：R1={<ai-1,ai>|ai-1∈D,i=2,…,n}基本操作：Status LisCreate_L(LinkList &L,int I,ElemType &e)操作结果：在不带头结点的单链表L中，创建第i个元素，并用e赋值}2.本程序中包括的两个基本模块：1)主程序模块：Void main(){初始化；do{接受命令；处理命令；}while(“命令”=”退出”)}2)循环链表模块：实现循环链表的抽象数据结构三、详细设计1.结点类型typedef struct ListNode{int mi;int n;struct ListNode *next;}ListNode,*LinkList;2.用循环链表存储约瑟夫环，没有头结点，基本操作函数如下：void CreateList(LinkList&L, int n){LinkList s;int i;L=(LinkList)malloc(sizeof(ListNode));L->n=1;L->next=L;for(i=2;i<=n;i++){s=(LinkList)malloc(sizeof(ListNode));s->next=L->next;L->next=s;s->n=i;L=L->next;}}void Delete(LinkList L, int m){int i;LinkList p,q;p=L;while(p->next!=p){for(i=1;i<m;i++)p=p->next;q=p->next;m=q->mi;printf("%d ",q->n);p->next=q->next;free(q);}printf("%d ",p->n);free(p);}3.主函数：int main(){int n,i,m;LinkList L,p;printf("请输入人数:");scanf("%d",&n);CreateList(L,n);printf("请输入密令\n");p=L->next;for(i=1;i<=n;i++){printf("请输入第%d条密令\n",i);scanf("%d",&p->mi);p=p->next;}printf("请输入初始密令\n");scanf("%d",&m);printf("输出为\n");Delete(L, m);return 0;}四、调试分析1.第一次写时，没有区分出只剩下的一个的情况，导致最终输出出现错误。

实验报告约瑟夫问题

pNew->next = pCur->next;
pCur->next = pNew;
pCur = pNew;
printf("结点%d,密码%d\n",pCur->id, pCur->cipher);
}
}
printf("完成单向循环链表的创建!\n");
}
(3)运行"约瑟夫环"问题
static void StartJoseph(NodeType **, int)
exit(-1);
}
pNew->id = iId;
pNew->cipher = iCipher;
pNew->next = NULL;
return pNew;
}
(6)测试链表是否为空,空为TRUE，非空为FALSE
static unsigned EmptyList(const NodeType *pHead)
实验内容
利用循环链表实现约瑟夫环求解。
实验说明
1.问题描述
约瑟夫问题的：编号为1，2，....,N的N个人按顺时针方向围坐一圈,每人持有一个密码(正整数)，一开始任选一个正整数作为报数上限值M，从第一个人开始按顺时针方向自1开始顺序报数，报到M时停止报数。报M的人出列，将他的密码作为新的M值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。
{
if(!pHead)
{
return TRUE;
}
return FALSE;
}
实验中遇到的问题及解决方法
实验结果如下：
实验总结（结果和心得体会）

约瑟夫生死游戏(C++)数据结构实现

约瑟夫生死游戏(C++)数据结构实现本文档为约瑟夫生死游戏的C++数据结构实现文档，旨在详细介绍如何使用C++语言实现约瑟夫生死游戏的功能。

1：引言1.1 背景约瑟夫生死游戏是一个经典的数学问题，由约瑟夫·斯特恩提出。

问题描述如下：有n个人围成一圈，从某个人开始，每次顺时针报数m个人，报到m的人出局，直到剩下最后一个人为止。

1.2 目的本文档旨在指导开发人员使用C++语言实现约瑟夫生死游戏的功能，包括实现报数、出局等基本操作，并提供相应的测试样例和使用说明。

2：设计2.1 数据结构设计约瑟夫生死游戏的核心是一个环形链表，链表中的每个节点代表一个人。

每个节点包含两部分数据：该人的编号和指向下一个节点的指针。

链表的最后一个节点指向第一个节点，形成环形结构。

2.2 算法设计- 初始化链表：根据输入的人数创建相应数量的节点，并通过指针连接起来，形成环形链表。

- 报数出局：从指定的起始位置开始顺时针遍历链表，依次报数，当报到m时，将该节点从链表中移除。

- 判断游戏结束：当只剩下最后一个节点时，游戏结束。

2.3 功能设计- 初始化游戏：根据输入的人数和报数间隔，创建约瑟夫生死游戏实例。

- 开始游戏：执行报数出局操作，直到游戏结束。

- 获取胜利者：返回最后剩下的节点的编号。

3：实现下面给出C++语言实现约瑟夫生死游戏的核心代码。

```cppinclude<iostream>using namespace std;// 定义环形链表节点结构体struct Node {int id;Node next;};class JosephusGame {public:// 构造函数，初始化环形链表JosephusGame(int n, int m) {// 创建第一个节点Node firstNode = new Node;firstNode->id = 1;firstNode->next = NULL;// 依次连接剩余节点Node prevNode = firstNode;for (int i = 2; i <= n; i++) { Node newNode = new Node; newNode->id = i;newNode->next = NULL;prevNode->next = newNode;prevNode = newNode;}// 最后一个节点和第一个节点，形成环形结构prevNode->next = firstNode;// 初始化成员变量this->head = firstNode;this->count = n;this->interval = m;}// 游戏主循环void playGame() {Node currentNode = this->head;while (this->count > 1) {// 找到要出局的节点的前一个节点for (int i = 1; i < this->interval; i++) { currentNode = currentNode->next;}// 删除当前节点Node removedNode = currentNode->next; currentNode->next = removedNode->next; delete removedNode;this->count--;// 移动当前节点到下一个节点currentNode = currentNode->next;}}// 获取胜利者的编号int getWinner() {return this->head->id;}private:Node head; // 链表头节点int count; // 当前剩余人数int interval; // 报数间隔};int mn() {int n, m;cout << \。

约瑟夫生死游戏课程设计(含源代码可以运行)

{
node* p = head;
int peopleOfNow = totalPeople;
while(peopleOfNow>alivePepole)
{
//找到顺时针要删除节点的前一节点p
for(int i =1; i<num1 - 1;i++)
{
p = p->next;
}
//删除顺时针时的节点
node* toBeDeleted = p->next;
node* tobeDeleted = s->left;
printf("deadman = %d\n",tobeDeleted->value);
node* leftToBeDeleted = tobeDeleted->left;
s->left = leftToBeDeleted;
leftToBeDeleted->next = s;
本游戏的要求用户输入的内容包括：
1. 旅客的个数，也就是n的值；
2. 正向离开旅客的间隔数，也就是m的值；
3. 反向离开旅客的间隔数，也就是k的值；
4. 所有旅客的序号作为一组数据要求存放在某种数据结构中。
本游戏要求输出的内容是包括
1. 离开旅客的序号；
2. 剩余旅客的序号；
所以，根据上面的模型分析及输入输出参数分析，可以定义一种数据结构后进行算法实现。
}
p->next = head;
head->left = p;
return head;
}
3.2 生者与死者的选择
int deleteList(node* head, int num1,int num2,int totalPeople,int alivePepole)//num1代表顺时针数 num2代表逆时针数

数据结构课程设计题目

算法与数据结构课程设计一、线性表题1、建立一个单链表，显示链表中每个节点的数据，并做删除和插入处理。

例：（掌握线性表在链式存储结构下的基本运算的实现。

）1、功能（1）建立以带头结点的单链表（2）显示链表中每个结点的数据（3）在单链表中指定位置插入指定数据并输出单链表中所有数据（4）删除单链表中指定的结点并输出单链表中所有数据2、输入要求输入单链表中所有数据，插入的数据元素的位置、值，要删除的数据元素的位置。

3、测试数据单链表中所有数据：12，23，56，21，8，10，15，67，90，32插入的数据元素的位置、值：1，28要删除的数据元素的位置：10[概要设计]（1）算法思想：由于在操作过程中要进行插入、删除操作，为运算方便，选用单带头结点的单链表作数据元素的存储结构。

对每个数据元素，由一个数据域和一个指针域组成，数据域放输入的数据值，指针域指向下一个结点。

（2）数据结构单链表结点类型：typedef struct Node{ int data;struct node *next;}ListNode;带头结点的单链表类型定义：typedef ListNode *LinkList;（3）模块划分：①建立点头结点的单链表CreatLinkList;②显示链表中每个结点的数据PrintList；③在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList;④删除单链表中指定的结点并输出单链表中所有数据DeleteList;⑤主函数mian()，功能是给出测试数据值，建立测试数据值的带头结点的单链表，调用PrintList函数、InsertList函数、DeleteList函数实现问题要求。

[详细设计] 见程序LinkList.c题2、约瑟夫环（Joseph）问题的一种描述是：编号1，2，┉，n的n个人按顺时针方向围坐一圈，每个人持有一个密码（正整数），一开始，任选一个正整数作为报数上线值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。

模板约瑟夫环(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）

数据结构与算法（Python版）：用队列（Queue）处理约瑟夫问题

数据结构与算法（Python版）：⽤队列（Queue）处理约瑟夫问题在古罗马时期，犹太⼈背叛了罗马⼈，落到困境，约瑟夫和同⾏的⼀共39个犹太⼈只能够⾃杀殉国，但是犹太教义规定不能⾃杀，因此只能够让别⼈将⾃⼰杀害。

他们所有39个⼈坐成⼀圈，报数1—7，报到7则由⾝旁的⼈将⾃⼰杀死。

结果约瑟夫灵机⼀动，给⾃⼰安排了⼀个位置，最后活了下来，那么约瑟夫给⾃⼰安排的是哪⼀个位置呢？在这个题⽬当中，我们如果使⽤队列，不仅可以处理任意⼈数坐成⼀圈，还可以将报数的值任意修改，最后都可以找到那⼀个不被杀死的⼈的位置。

我们可以将所有⼈都放进⼀个⼤的队列⾥，每报⼀次数字，那么就把队列头部的⼈放到队列的尾部，直到报数报到⼀组数字的最后⼀个，⽐如1——7当中的7。

这个时候就将队列头的这个⼈删除（也就是杀死），不断执⾏这个过程，直到整个队列当中的⼈数只有⼀个，则跳出循环返回最后活着的那个⼈的名字。

⾸先定义队列（Queue）类的结构：class Queue():def__init__(self):# 初始化⼀个空的列表self.__list=[]# 往队列⾥插⼊元素def enqueue(self,item):self.__list.append(item)# 弹出队列⾥的元素def dequeue(self):return self.__list.pop(0)# 弹出队列⾥最先进⼊的元素# 判断队列是否为空def is_empty(self):return self.__list == []# 计算队列的⼤⼩def size(self):return len(self.__list)使⽤队列类来初始化⼀个对象，sim_queue,然后编写刚才我们分析之后的程序：def hot_potato(namelist,num):sim_queue = Queue()for name in namelist:sim_queue.enqueue(name) # 把拿到的名字全部都放到队列⾥while sim_queue.size() > 1:for i in range(num):sim_queue.enqueue(sim_queue.dequeue())# 每执⾏完⼀次，就将队列的头拿出来弹出，相当于⼟⾖传递给这个⼈，然后这个⼈就死了last_person=sim_queue.dequeue()return last_personprint("开始执⾏约瑟夫问题")print(hot_potato(["bob","NAni","Ao li Gei!","HeHe","Mike","Suvennia"],4))输出：开始执⾏约瑟夫问题Ao li Gei!得解，因此Ao li Gei!这个⼈不会被杀死。

约瑟夫问题

约瑟夫问题一、问题描述和要求1、问题描述约瑟夫问题是这样的：设有n个人围圆桌坐成一圈，现从第s个人开始报数，数到m的人出列，接着从出列的下一个人开始重新报数，数到m的人又出列，如此重复下去，直到所有人都出列为止。

2、程序设计要求（1）、通过本学期《数据结构》的学习，综合运用已学过的理论和技能去分析和解决约瑟夫问题，加深对数据结构课程理论的理解和运用、切实加强自己的实践动手能力和创新能力。

（2）、结合C语言程序设计、数据结构中所学的理论知识，小组独立设计方案，培养分析与解决问题的能力。

（3）、学会查阅相关手册和资料，进一步熟悉常用算法的用途和技巧，掌握这些算法的具体含义。

（4）、认真调试程序，学会改正程序中的错误，尝试不同的方法实现同一功能，培养严谨的作风和科学的态度。

二、个人所负责的工作1、算法思路约瑟夫问题的解决可以用线性链表，循环链表，数组等多种方法，我们采用线性链表解决该问题，采用分块的设计思路，利用函数调用解决问题。

本算法采用for循环解决线性链表的建立，用printf函数输出链表，利用for循环找到第s个人开始报数，再利用一个for循环找到第m个人，然后多重if语句讨论不同情况的处理，最后通过函数调用解决约瑟夫问题。

2、我负责的工作在这次程序设计中，我主要负责对整个题目设计思路进行分析和对程序的注释。

我们刚设计出来的程序存在着种种问题，各部分程序都需要进行一定的修改和完善，比如线性链表不能够正常输入，主函数对用户的输入要求的描述太过笼统，输出函数不能调用等等。

我就是不断发现这些问题并完善它们，使程序能够正确的运行。

然后我和其他组员经过商议，对程序的各部分含义进行注释。

在程序演示时我主要负责对整个题目设计思路分析及组员介绍。

以下是我修改过的程序之一:NODE *creatlinklist(int n)/*建立线性链表*/{ int i;NODE *head,*p,*q;/*定义整形实参i，指针head、p、q*/if(n==0)return(NULL);/*如果n=0建立一个空链表*/elsehead=(NODE *)malloc(sizeof *head);/*申请一个结点为表头*/q=head;for (i=1;i<=n;i++)/*将n个结点输入到单链表中*/{p=(NODE *)malloc(sizeof *head);printf("输入数据:");p->info=getche();/*getche功能: 输入后立即从控制台取字符，不以回车为结束*/printf("\n");q->next=p;/*q指向表尾，准备导入下一个结点*/q=p;}p->next=NULL;/*将最后一个结点的链域置为空*/return(head);}三、结论经过这次程序设计任务，我认真的复习了数据结构中学习过的理论知识，尤其是对线性链表这一部分进行了认真的归纳总结，对数据结构的认识更深刻了，对线性链表的建立、插入、删除、查找等操作的运用更加熟练，对for循环、输入输出函数等更加了解，而且我意识到今后我可以利用这些函数解决更多的实际问题。

数据结构课程设计约瑟夫环

《数据结构》课程设计报告书题目：约瑟夫环系别：计算机科学与应用学号：学生姓名：指导教师：完成日期：2012年6月7日目录1．需求分析 (3)1.1 功能分析 (3)1.2开发平台 (3)2．概要设计 (3)3. 程序设计主要流程 (5)4．调试与操作说明 (5)4.1调试情况 (5)4.2操作说明 (6)总结 (8)致谢 (9)附录 (9)参考文献 (13)指导教师评语： (14)1．需求分析1.1 功能分析本次选做的课程设计是改进约瑟夫(Joseph)环问题。

约瑟夫环问题是一个古老的数学问题，本次课题要求用程序语言的方式解决数学问题。

此问题仅使用单循环链表就可以解决此问题。

在建立单向循环链表时，因为约瑟夫环的大小由输入决定。

为方便操作，我们将每个结点的数据域的值定为生成结点时的顺序号和每个人持有的密码。

进行操作时，用一个指针r指向当前的结点，指针H指向头结点。

然后建立单向循环链表，因为每个人的密码是通过scanf()函数输入随机生成的，所以指定第一个人的顺序号，找到结点，不断地从链表中删除链结点，直到链表剩下最后一个结点，通过一系列的循环就可以解决改进约瑟夫环问题。

1.2开发平台WindowsXP操作系统；Microsoft Visual C++ 6.0；2．概要设计编号为1，2… n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。

一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他的顺时针方向上的下一个开始重新从1报数，如此下去，直至所有人全部出列为止，设计一个程序求出出列顺序。

这个问题采用的是典型的循环链表的数据结构，就是将一个链表的尾元素指针指向队首元素。

r->next=H。

解决问题的核心步骤：首先建立一个具有n个链结点，无头结点的循环链表。

然后确定第1个报数人的位置。

最后不断地从链表中删除链结点，直到链表为空。

约瑟夫环课程设计实验报告

《数据结构》课程设计报告课程名称: 《数据结构》课程设计课程设计题目: joseph环姓名：院系：计算机学院专业：年级：学号：指导教师:2011年12月18日目录1 课程设计的目的 (2)2 需求分析 (2)3 课程设计报告内容 (3)1.概要设计 (3)2.详细设计 (3)3.调试分析 (x)4.用户手册 (x)5.测试结果 (6)6.程序清单 (7)4 小结 (10)1、课程设计的目的（1）熟练使用C++编写程序, 解决实际问题；（2）了解并掌握数据结构与算法的设计方法, 具备初步的独立分析和设计能力；（3）初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；（4）提高综合运用所学的理论知识和方法独立分析和解决问题的能力；2、需求分析1.问题描述:编号是1, 2, ……,n的n个人按照顺时针方向围坐一圈, 每个人只有一个密码（正整数）。

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

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

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

2.要求:利用不带表头结点的单向循环链表存储结构模拟此过程, 按照出列的顺序输出各个人的编号。

3.测试数据:m的初值为20, n=7 ,7个人的密码依次为3, 1, 7, 2, 4, 7, 4, 首先m=6,则正确的输出是什么？输出形式：建立一个输出函数, 将正确的输出序列3.课程设计报告内容概要设计:在理解了题目后, 我先想到的是我们所学的单链表, 利用单链表先建立循环链表进行存贮, 建立完循环链表后, 我将所要编写的函数分为了两块, 一块是经过学过的单链表改编的循环链表的基本操作函数, 还有一块是运行约瑟夫环的函数。

详细设计:我先建立一个结构体, 与单链表一样, 只是多了一个存密码的code域struct LinkNode{int data; //顺序int code; //密码LinkNode *next;};建立一个类LinkList ,包含的函数:LinkList(); //构造函数void Creat(const int ); //创建循环链表int Delete(LinkNode* ); //删除报到数的结点int Joseph(int ); // 约瑟夫环私有成员是LinkNode* head; //指向第一个结点的指针LinkNode* elem; // 同上int len; //长度我定义了一个elem指针是为了约瑟夫环里运行方便, elem只在约瑟夫环这个函数里用到, 其他函数没有特别大的用处。

数据结构约瑟夫环问题

数据结构实验报告题目：约瑟夫环问题一．设计内容[问题描述]约瑟夫环问题的一种描述是：编号为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。

数据结构joseph课程设计

数据结构joseph课程设计一、课程目标知识目标：1. 学生能理解约瑟夫问题（Josephus problem）的背景和数学原理，掌握其与数据结构中循环链表的关系。

2. 学生能够掌握循环链表的基本操作，包括节点的插入、删除以及遍历。

3. 学生能够运用所学的循环链表知识解决约瑟夫问题，并理解其算法的效率。

技能目标：1. 学生能够运用编程语言（如C/C++/Java等）实现循环链表，并完成相应的约瑟夫问题求解程序。

2. 学生通过实际操作循环链表，提高逻辑思维能力和编程实践能力。

3. 学生能够通过分析、讨论和解决问题，培养团队协作能力和问题解决能力。

情感态度价值观目标：1. 学生通过解决实际问题，增强对数据结构学习的兴趣和热情，形成积极向上的学习态度。

2. 学生在团队协作中学会尊重他人，培养良好的沟通能力和合作精神。

3. 学生通过探究和解决约瑟夫问题，体会数学和计算机科学的实际应用价值，增强对科学的敬畏之心。

课程性质：本课程设计属于数据结构学科范畴，以实践操作和问题解决为核心，强调理论与实践相结合。

学生特点：考虑到学生已具备一定的编程基础和逻辑思维能力，课程设计将注重培养学生的实践能力、团队协作能力以及创新意识。

教学要求：教师应关注学生的个体差异，因材施教，引导学生通过自主探究、合作学习等方式达到课程目标。

在教学过程中，注重过程评价和结果评价相结合，全面评估学生的学习成果。

二、教学内容本节教学内容围绕数据结构中的循环链表及其应用——约瑟夫问题展开，具体安排如下：1. 循环链表基础知识回顾：- 循环链表的定义与特点- 循环链表的节点结构- 循环链表与普通链表的区别2. 循环链表的操作：- 节点的插入与删除- 循环链表的遍历- 循环链表的应用场景3. 约瑟夫问题介绍：- 约瑟夫问题的背景和数学原理- 约瑟夫问题与循环链表的关系4. 约瑟夫问题求解：- 算法设计思路- 编程实现步骤- 算法效率分析5. 实践环节：- 编写循环链表的基本操作函数- 编写求解约瑟夫问题的程序- 调试与优化程序6. 教学案例分析：- 结合实际案例，讲解循环链表在解决约瑟夫问题中的应用- 分析案例中的算法优化方法教学内容根据课本相应章节进行组织，确保学生能够在掌握循环链表基础知识的基础上，学会解决实际问题。

约瑟夫环问题实验报告

}
//报数为m的人出列
while(n--)
{
for(int s=m-1; s--; r=p, p = p->link);
cout << "The output is: " << p->data << endl;
r->link = p->link;
LinkList d = new LNode;
if(!d)
二、实验问题描述
设编号为1，2，···，n的n个人围坐一圈，约定编号为k（1≤k≤n）的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
3、实验步骤
1、实验问题分析
①由于当某个人退出圆圈后，报数的工作要从下一个人开始继续，剩下的人仍要是围成一个圆圈，可以使用循环表；由于退出圆圈的工作对应着表中结点的删除操作，对于这种删除操作频繁的情况，应该选用效率较高的链表结构；为了程序指针每一次都指向一个具体的代表一个人的结点而不需要进行判断，链表不带表头结点。所以，对于所有人围成的圆圈所对对应的数据结构采用一个不带头结点的循环链表来描述。设头指针为p，并根据具体情况移动
可以采用数据类型定义： Typedef struct node {
int number;
struct node *next; }Lnode,*Linklist;
②为了记录退出的人的先后顺序，采用一个顺序表进行存储，程序结束后再输入依次退出的人的编号顺序。由于只记录各个结点的number值就可以，所以定义一个整型一维数组。如“int quite[N];”N为一个根据实际问题定义的一个足够大的整数。

约瑟夫问题实验报告

约瑟夫问题实验报告（文章一）：约瑟夫问题数据结构实验报告中南民族大学管理学院学生实验报告实验项目: 约瑟夫问题课程名称：数据结构年级：专业：信息管理与信息系统指导教师：实验地点：管理学院综合实验室完成日期：小组成员：学年度第（一）、实验目的（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 报数，如此下去，直至所有人全部出列为止。

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

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

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

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

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

约瑟夫环问题是算法设计中的一个经典问题，是顺序编号的一组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;

约瑟夫环与八皇后问题--数据结构课程设计实验报告

目一、二、三、四、五、六、七、
录问题描述 1 问题分析 1 数据结构描述算法设计 2 详细程序清单程序运行结果心得体会 12
1 4 11
一、问题描述 1. 约瑟夫问题描述编号为1，2... n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他的顺时针方向上的下一个开始重新从1报数，如此下去，直至所有人全部出列为止，设计一个程序求出出列顺序。 2. 八皇后问题描述在一个８×８的棋盘里放置８个皇后，要求每个皇后两两之间不相"冲"（在每一横列竖列斜列只有一个皇后）。 3、界面设计模块问题描述设计一个菜单式界面，让用户可以选择要解决的问题，同时可以退出程序。界面要简洁明了，大方得体，便于用户的使用，同时，对于用户的错误选择可以进行有效的处理。二、问题分析在整个课程设计中，我主要负责的是约瑟夫问题中链表中的出列的操作算法的设计。用循环单链表表示编号为1，2... n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始输入一个正整数作为报数的上限值turn，从第一个人开始按顺时针方向自1开始顺序报数（即从第一个结点开始指针向后移动），报到turn-1时（即指针指向 turn-1个结点时）停止，他的下一位出列，将他的下一位密码作为新的turn值，从出列的人的的顺时针方向上的下一个开始重新从1报数，如此下去，直至链表中只剩一位（即一个结点）退出循环，并所有人的编号按出列顺序输出。在实现的过程中定义i表示报数的
int code; struct LNode *next; }node,*linklist; linklist creatstart(linklist L,int number) { int m,i; linklist s,p; s=L; for(i=1;i<=number;i++) { p=(linklist)malloc(sizeof(node)); if(!p) exit(0); p->data=i; printf("please input the code of number %d:",i); scanf("%d",&p->code); p->next=NULL; s->next=p; s=p; } s->next=L->next; return s; } void chulie(linklist L,int number) { int turn,i,j; linklist p,s; printf("please input the start code:"); scanf("%d",&turn); p=L; printf("the turn out of the circle is:"); for(i=1;i<=number-1;i++) { for(j=1;j<=turn-1;j++) p=p->next; printf("%d ",p->next->data); turn=p->next->code; s=p->next; p->next=s->next; free(s); } printf("%d ",p->next->data); printf("\n"); } void lianbiao() { int number; linklist L; L=(linklist)malloc(sizeof(node));

数据结构实验报告一-约瑟夫环问题

实验1约瑟夫环问题1．需求分析（1）输入的形式和输入值的范围：每一次输入的值为两个正整数，中间用逗号隔开。

若分别设为n,m，则输入格式为：“n,m”。

不对非法输入做处理，即假设输入都是合法的。

（2）输出的形式：输出格式1：在字符界面上输出这n个数的输出序列输出格式2：将这n个数的输出序列写入到文件中（3）程序所能达到的功能：对于输入的约瑟夫环长度n和间隔m，输出约瑟夫环的出列顺序。

（4）测试数据：包括正确的输入及其输出结果和含有错误的输入及其输出结果。

正确：输入：10,3输出：3 6 9 2 7 1 8 5 10 4输入：41,3输出：3 6 9 12 15 18 21 24 27 30 33 36 39 1 5 10 14 19 23 28 32 37 41 7 13 20 2634 40 8 17 29 38 11 25 2 22 4 35 16 31错误：输入：10 3输出：6 8 7 1 3 4 2 9 5 102．概要设计（1）抽象数据类型的定义：为实现上述程序的功能，可以用整数存储用户的输入。

并将用户输入的值存储于线性表中。

线性表ADT定义如下：ADT list数据对象：整形数据关系：线性关系，即<ai,ai+1>(0≤a＜n)。

基本操作：bool remove(int &elem)//移除一个元素，被移除的元素赋给elem//如果操作成功，返回true,否则返回falsebool isEmpty()//判断数组的元素是否清空，空返回true,否则返回falsebool setPos(int place)//设置当前元素的位置，设置成功返回true,否则返回falseint getLength()//获取数组的实际长度（2）算法的基本思想：约瑟夫环问题中的数据是人所在的位置，而这种数据是存在“第一元素、最后元素”，并且存在“唯一的前驱和后继的”，符合线性表的特点。

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

约瑟夫问题

实验报告——约瑟夫环

实验报告 约瑟夫问题

约瑟夫生死游戏(C++)数据结构实现

约瑟夫生死游戏课程设计(含源代码可以运行)

数据结构课程设计题目

模板约瑟夫环(Joseph)问题.ppt

数据结构与算法（Python版）：用队列（Queue）处理约瑟夫问题

约瑟夫问题

数据结构课程设计约瑟夫环

约瑟夫环课程设计实验报告

数据结构约瑟夫环问题

数据结构joseph课程设计

约瑟夫环问题实验报告

约瑟夫问题实验报告

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

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

约瑟夫环与八皇后问题--数据结构课程设计实验报告

数据结构实验报告一-约瑟夫环问题

实验报告约瑟夫问题

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