约瑟夫环课程设计实验报告
约瑟夫环实验报告
约瑟夫环实验报告约瑟夫环是一个经典的数学问题,它涉及到一个有趣的游戏。
这个游戏的规则是:有N个人站成一圈,从某个人开始,每报数到第M个人,就将该人从圈中移出去,再从下一个人开始重新报数,如此循环,直到只剩下一个人为止。
那么,我们将通过实验来探究一下约瑟夫环的性质和一些有趣的现象。
首先,我们设定了一组实验条件。
假设有10个人,从1到10编号,报数为3。
我们选择从编号为1的人开始报数,然后每次报数到第3个人。
接下来,我们按照约瑟夫环的规则进行实验。
实验开始后,我们可以观察到一系列有趣的现象。
首先,被淘汰的人并不会立即离开圈子,而是继续留在原位,但不再参与后续的报数和淘汰。
当每次报数到达M的倍数时,即到了第3个人、第6个人、第9个人等等,这些人就会被逐渐淘汰出圈。
在实验过程中,我们发现了一个有趣的规律。
剩下的人似乎总是固定按照一定的顺序被淘汰。
为了更好地观察这个规律,我们进行了多组实验,并记录了淘汰顺序。
首先,在报数为3的情况下,我们记录了当有10个人时的淘汰顺序。
开始时,第1轮淘汰的是第3个人,然后是第6个人,之后是第9个人。
接着,轮到第2个人被淘汰,然后是第7个人,最后是第1个人。
可见,在这个实验条件下,被淘汰的顺序是3、6、9、2、7、1。
我们可以看到,在最后几轮淘汰时,被淘汰的顺序逐渐回到了初始的编号1。
接着,我们将实验条件略作改变,观察是否会出现相似的淘汰顺序。
这次,我们依然有10个人,报数为4。
开始时,第1轮淘汰的是第4个人,然后是第8个人,之后是第2个人。
接着,轮到第5个人被淘汰,然后是第10个人,最后是第6个人。
通过这次实验,我们可以观察到一些不同之处。
尽管淘汰的顺序在最后几轮回到了初始的编号1,但淘汰的间隔变得更长了,而且整体的淘汰顺序也有了一定的变化。
通过对约瑟夫环实验的多次观察和记录,我们可以总结出一些结论。
首先,淘汰的顺序呈现出周期性,并在最后几轮回到了初始的编号。
其次,在不同的实验条件下,淘汰的规律可能会有所不同。
实验一约瑟夫环问题实验报告
题目二约瑟夫环问题设编号为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; //使用后插法插入。
约瑟夫环问题 实验报告
return count==0; } template <class T> bool SqList<T>::Full() const { return count==maxsize; } template <class T> int SqList<T>::Length() const { return count; } template <class T> void SqList<T>::Clear() { count=0; //这里并不是将所有元素删除,而是将元素个数置 0,实际上元素还在,但可以重新输入元素替换原来的元素 } template <class T> bool SqList<T>::SetElem(int position,const T &e) { if(position<1||position>Length()) //范围出错 { cout<<"范围出错,无法赋值!"<<endl; return false; } else { elems[position-1]=e; return true; } }
for(;i<=m;i++) { j++; if(j>len) j=1; while(S.GetElem(j)==0) { j++; if(j>len) j=1; } } if(j==0) j=1; cout<<S.GetElem(j)<<" "; S.SetElem(j,0); flag++; i=1; } cout<<endl; } return 0; } 测试用例:
约瑟夫环课程设计实验报告
约瑟夫环课程设计实验报告《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目: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; /删除的是尾结点时(不知道为什么我写程序里总是编译出现错误){q->next=head; //重新链接delete a;len--;return out;}else{q->next=a->next; delete a;len--;return out;}}}}5、测试结果:6 程序清单:#include <>struct LinkNode{int data;int code;LinkNode *next;};class LinkList{public:LinkList();void Creat(const int ); //~LinkList();int Delete(LinkNode* );int Joseph(int );private:LinkNode* head;LinkNode* elem;int len;};LinkList::LinkList(){head=elem=NULL;len=0;}void LinkList::Creat(const int number) {if(number==1){head=elem=new LinkNode;head->data=1;cout<<"请输入密码:"<<endl;< bdsfid="152" p=""></endl;<> cin>>head->code;head->next=head;}else{head=elem=new LinkNode;head->data=1;cout<<"请依次输入各个密码:"<<endl;< bdsfid="161" p=""></endl;<>cin>>head->code;LinkNode*q=head;q=head;for(int i=1;i<number;i++)< bdsfid="166"p=""></number;i++)<>{LinkNode*p=new LinkNode;p->data=i+1;cin>>p->code;q->next=p;q=p;}q->next=head;}len=number;}int LinkList::Delete(LinkNode *a){if(len>1){if(head==a){int out=head->data;LinkNode* q=head;while(q->next!=head){q=q->next;}q->next=head->next;head=head->next;delete a;len--;return out;}else{LinkNode* q=head;int out=a->data;while(q->next!=a){q=q->next;}q->next=a->next;delete a;len--;return out;}}}int LinkList::Joseph(int m){if(len>1){LinkNode *q;if(m==1){q=elem;int a=q->code;elem=elem->next;cout<<delete(q)<<endl;< bdsfid="222" p=""></delete(q)<<endl;<>Joseph(a);}else{for(int i=1;i<m;i++)< bdsfid="228" p=""></m;i++)<>elem=elem->next;q=elem;elem=elem->next;int a=q->code;cout<<delete(q)<<endl;< bdsfid="234" p=""></delete(q)<<endl;<>Joseph(a);}}elsecout<data;}int main(){int num,code;cout<<"请输入人数: ";cin>>num;LinkList L;(num);cout<<"请输入第一个上限数: ";cin>>code;cout<<"出列顺序:"<<endl;< bdsfid="252" p=""></endl;<> (code);return 0;}4、小结一、这次课程设计的心得体会通过实践我的收获如下:一开始接触数据结构课程设计真的挺难的,好多都不会,不是逻辑方面的问题,而是不具备动手能力,脑子里总有一团火,比如对于这个题目,一开始有很多的想法,想到了从逻辑上怎么实现他,要编写哪些程序,但是一到需要编写了就开始为难了,可以说是几乎不知道从哪里入手,参考了书本里的程序,仿照他的结构一步一步做下来,现在对于单链表的各种操作已经算是比较熟练了,让我知道光有理论知识还远远不够,需要多动手,写的多了自然就能手到擒来。
约瑟夫环问题实验报告
约瑟夫问题实验报告背景约瑟夫问题(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个数输出到屏幕上三.详细设计首先,设计实现约瑟夫环问题的存储结构。
实验报告 约瑟夫问题
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;
}
实验中遇到的问题及解决方法
实验结果如下:
实验总结(结果和心得体会)
约瑟夫环实验报告
约瑟夫环问题实验报告一、实验内容本实验利用单向循环链表模拟约瑟夫环问题(编号为1,2,…,n的n个人按顺时针方向围坐一圈,没人持有一个密码(正整数)。
开始任选一个正整数作为报数上限值m,从第一个人开始按顺时针方向自1开始报数,报到m是停止报数。
报m的人出列,将他的密码作为新的m值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止),按照出列顺序印出个人的编号。
M的初值为20,n=7,7个人的密码依次为3,1,7,2,4,8,4,首先m值为6。
二、源程序#include"stdafx.h"#include<iostream>using namespace std;#include<conio.h>//getch();/*write: Han.JH*/static int people_number_count; typedef struct People_Node{int Password_Data,people_number;struct People_Node *next;}People_Node,*People_LinkList;void GreatList(People_LinkList &L){People_Node *s,*r; int flag=1;int Password;L=new People_Node;L->next=NULL;r=L;while(flag==1){cout<<"输入每个人的密码,以回车作间隔,'0'表示结束:";cin>>Password;//输入每个人的密码;if(Password!=0){s=new People_Node;s->Password_Data=Password;people_number_count++; //对人的编号s->people_number=people_number_count;r->next=s;r=s;}else{ r->next=L->next;flag=0;}}}void GetList(People_LinkList &L){People_Node *r;int m,k;int count=0;cout<<"输入报数上限值m:";cin>>m;r=L;cout<<"出列排序:";while(count!=people_number_count){ //则所有人以出列,结束循环for(k=1;k<=m-1;k++){r=r->next;}count++;m=r->next->Password_Data;cout<<"["<<r->next->people_number<<"]";r->next=r->next->next;}}void main(){People_LinkList L;void GreatList(People_LinkList &);void GetList(People_LinkList &);cout<<"++++++++++++约瑟夫环问题+++++++++++"<<endl;GreatList(L);GetList(L);cout<<"[--结束--]"<<endl;getch();}三、调试刚开始调试时出现了无法打开<iostream.h>头文件的错误,经过上网查询,#include<iostream.h>是C语言风格,但是在标准 C 里面,是不用#include <iostream.h>的,而要使用#include <iostream>把#include<iostream.h>改为:#include<iostream>using namespace std;后,问题解决。
数据结构约瑟夫环实验报告
《数据结构与算法设计》约瑟夫环实验报告——实验一专业:物联网工程班级:物联网1班学号:15180118姓名:刘沛航一、实验目的1、熟悉VC环境,学习使用C语言利用链表的存储结构解决实际的问题。
2、在编程、上机调试的过程中,加深对线性链表这种数据结构的基本概念理解。
3、锻炼较强的思维和动手能力和更加了解编程思想和编程技巧。
二、实验内容1、采用单向环表实现约瑟夫环。
请按以下要求编程实现:①从键盘输入整数m,通过create函数生成一个具有m个结点的单向环表。
环表中的结点编号依次为1,2,……,m。
②从键盘输入整数s(1<=s<=m)和n,从环表的第s个结点开始计数为1,当计数到第n个结点时,输出该第n结点对应的编号,将该结点从环表中消除,从输出结点的下一个结点开始重新计数到n,这样,不断进行计数,不断进行输出,直到输出了这个环表的全部结点为止。
例如,m=10,s=3,n=4。
则输出序列为:6,10,4,9,5,2,1,3,8,7。
三、程序设计1、概要设计为了解决约瑟夫环的问题,我们可以建立单向环表来存储每个人的信息(该人的编号以及其下一个人的编号),及结点,人后通过查找每个结点,完成相应的操作来解决约瑟夫问题。
(1) 抽象数据类型定义ADT Joh{数据对象:D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥K数据关系:R1=11{,|,,1,2,,}i i i i a a a a D i n --<>∈=K基本操作:create(&J, n)操作结果:构造一个有n 个结点的单向环表J 。
show(J)初始条件:单向环表J 已存在。
操作结果:按顺序在屏幕上输出J 的数据元素。
calculate( J,s,n)初始条件:单向环表J 已存在,s>0,n>0,s<环表结点数。
操作结果:返回约瑟夫环的计算结果。
}ADT Joh(2)宏定义#define NULL 0#define OK 1#define ERROR -1(3)主程序流程(4)程序分为下述模块:1)主函数模块——执行输入调用其他的功能函数2)创建环表模块——创建单向环表3)计算处理模块——计算出要出列的标号并输出4)显示模块——输出建立好的环表调用关系如下:2、详细设计(1)数据类型设计typedef int ElemType; //元素类型typedef struct {ElemType data;struct Joh *next;}Joh, *LinkList,*p; //结点类型,指针类型(2)操作算法Status create(LinkList &J,int n){//创建一个有n个结点的单向环表if(n<=0)return ERROR; //n<0错误J=(LinkList)malloc(sizeof(J));J->data=1;J->next=J;//建立第一个结点for(int i=n;i>1;--i){p=(LinkList)malloc(sizeof(J));p->data=i;p->next=J->next;J->next=p;//插入到表头}return OK;}//createvoid show(LinkList J){//主要的操作函数//顺序输出环表J的结点p=J;printf("%d ",p->data);p=p->next;while(p!=J){ //循环终止条件printf("%d ",p->data);p=p->next;}}//showvoid calculate(LinkList J,int s,int n){p=J;Joh *head=p; //声明结点while(p->data!=s){p=p->next;head=p;}//寻找起始结点while(p->next!=p){ //终止条件for(int i=0;i<n-1;i++){head=p; //保存前置节点p=p->next;}printf("%d ",p->data);head->next=p->next; //删除已输出结点p=head->next;}if(n!=1)printf("%d\n",p->data);elseprintf("\n");}//calculate(3)主函数代码int main(){//主函数Joh *J;int m,s,n;printf("The num of node is:");scanf("%d",&m);create(J,m); //创建单向环表Jshow(J); //输出J的数据printf("\n");printf("The first node which you want is:");scanf("%d",&s);printf("The internal which you want is:");scanf("%d",&n);calculate(J,s,n); //计算并输出结果return 0;}//main四、程序调试分析1、细节决定成败,编程最需要的是严谨,如何的严谨都不过分,往往检查了半天发现错误发生在某个括号,分号,引号,或者数据类型上。
约瑟夫环 实验报告
约瑟夫环实验报告约瑟夫环实验报告引言:约瑟夫环是一个经典的数学问题,它源自于古代传说。
根据传说,古代犹太人被罗马人围困在一个洞穴中,他们决定用一种特殊的方式来决定谁将成为首领。
他们站成一个圆圈,从一个人开始,每隔一个人杀掉一个,直到只剩下一个人。
这个问题被称为约瑟夫环问题,它在数学领域引起了广泛的研究和探讨。
实验目的:本实验旨在通过模拟约瑟夫环问题,探讨其数学规律和解法,并分析实验结果的意义和应用。
实验步骤:1. 首先,我们需要确定参与约瑟夫环的人数n和每次报数的间隔m。
在本次实验中,我们选择了n=10和m=3。
2. 接下来,我们将10个人按顺序排成一个圆圈,并给每个人编号,编号从1到10。
3. 实验开始时,从第一个人开始报数,每次报数到m的人将被淘汰出局。
4. 淘汰的人将离开圆圈,下一个人将从淘汰者的下一个人开始报数,继续进行报数和淘汰的过程,直到只剩下一个人为止。
实验结果:通过模拟实验,我们得到了以下结果:- 第一轮淘汰的人依次为:3、6、9、2、7、1、8、5、10。
- 第二轮淘汰的人依次为:4、9、2、8、5、1、7、6。
- 第三轮淘汰的人依次为:9、8、5、1、7、4、6。
- 第四轮淘汰的人依次为:1、7、4、6、9、5。
- 第五轮淘汰的人依次为:7、4、6、9、5。
- 第六轮淘汰的人依次为:4、6、9、5。
- 第七轮淘汰的人依次为:6、9、5。
- 第八轮淘汰的人依次为:9、5。
- 第九轮淘汰的人依次为:5。
结论:通过实验结果的分析,我们可以得出以下结论:1. 在本次实验中,最后幸存的人是编号为5的人。
2. 根据实验结果,我们可以总结出约瑟夫环问题的一般解法。
假设总人数为n,每次报数的间隔为m,最后幸存的人的编号可以通过递归公式f(n,m)=[f(n-1,m)+m]%n得到。
3. 约瑟夫环问题在数学中具有一定的研究价值和应用意义。
它涉及到递归、数论等数学概念和方法,可以帮助我们更好地理解和应用这些数学知识。
约瑟夫环上机实验报告
约瑟夫环上机实验报告1. 概述约瑟夫环问题是一个经典的数学问题,该问题是以约瑟夫·弗拉维奥(Josephus Flavius)命名的,故称为约瑟夫环。
问题的具体描述如下:在编号为1到n的n 个人围成一个圆圈,从第一个人开始报数,报到m的人出列,然后从出列的下一个开始重新从1到m报数,再次报到m的人再次出列,如此循环下去,直到所有的人都出列为止。
本次实验旨在使用程序实现约瑟夫环的模拟,并观察对于不同的参数n和m,最后剩余的人的编号特点。
2. 实验设计2.1 算法设计本实验中采用循环链表来模拟约瑟夫环,首先构建一个含有n个结点的循环链表,每个结点表示一个人,每个结点的数据域存储该人的编号。
然后根据报数规则,依次遍历链表,当报数为m时,删除对应的结点。
直到链表中仅剩一个结点为止。
2.2 程序实现pythonclass ListNode:def __init__(self, val=0):self.val = valself.next = Nonedef josephus(n, m):if n == 0:return -1构建循环链表dummy = ListNode(-1)cur = dummyfor i in range(1, n + 1):node = ListNode(i)cur.next = nodecur = cur.nextcur.next = dummy.next模拟游戏过程count = 0while cur.next != cur:count += 1if count == m:cur.next = cur.next.nextcount = 0else:cur = cur.nextreturn cur.val3. 实验结果为了观察不同参数n和m对最后剩余的人的编号的影响,我们进行了多组实验。
结果如下:n m 最后剩余的人的编号5 2 310 3 415 4 1420 5 6从实验结果可以看出,最后剩余的人的编号与参数m有关,而与参数n无关。
约瑟夫环实验报告
程序结束输 出结果
源 程 序 及 注 释
#include<iostream> using namespace std; struct Node //记录乘客的信息 { Node * nextnum; int num; }; int main() { int n,m,l,retainer; cout<<"Input n,m,k:"<<endl; //输入 n、m、k 这三个数据 cin>>n>>m>>l; Node * former,* latter; former=latter=new Node; former->num=1; for(int i=1;i<n;i++) //开始构造链表 { Node *s=new Node; s->num=i+1; latter->nextnum=s; latter=s; } latter->nextnum=former; retainer=n; do { for(int data=1;data<m;data++){ //do while 循环语句来实行 latter=latter->nextnum; 指针的指向和修改 former=former->nextnum; } latter->nextnum=former->nextnum; delete former; former=latter->nextnum; retainer--; }while(retainer>l); cout<<"留下来的人的号码是:"<<endl; //输出结果, 找到被扔进大海里 for(int j=1;j<=l;j++) 的人 { cout<<former->num<<"\t"; former=former->nextnum; } return 0; }
约瑟夫环实验报告
约瑟夫环实验报告约瑟夫环(Josephus problem)是一个非常经典的数学问题,其得名于公元1世纪的犹太历史学家约塞夫斯(Josephus)。
约瑟夫环问题描述如下:n个人围坐成一个圆圈,从一些人开始依次报数,每报到第m个人,该人就被淘汰出圆圈,然后从下一个人重新开始报数。
直到剩下最后一个人时,即为问题的解。
例如,当n=7,m=3时,最后剩下的是4号人。
本次实验的目的是研究约瑟夫环问题的解决方法,并通过编程实现给定n和m的情况下找到最后的获胜者。
首先,我们需要分析问题的特点。
当n=1时,该问题的解即为最后剩下的人;当n>1时,最后剩下的人可以通过前一轮问题的解(剩下n-1个人的情况下)推导出来。
我们可以将解决该问题的方法分为两种:递归法和迭代法。
一、递归法递归法是通过问题的子问题来解决原问题。
对于约瑟夫环问题来说,递归法的解题思路如下:1.当n=1时,问题的解即为1;2.当n>1时,问题的解为(找到n-1个人时的解+m-1)对n取模,即((f(n-1,m)+m-1)%n)+1二、迭代法迭代法通过循环来解决问题,不断更新当前的解,直到问题得到解决。
对于约瑟夫环问题来说,迭代法的解题思路如下:1.初始化一个长度为n的数组a,a[i]=1表示第i个人还在圆圈中,a[i]=0表示第i个人已经被淘汰出圆圈;2. 从第一个人开始计数,每报数到第m个人,则将该人设为已淘汰,并计数器count加1;3. 重复步骤2,直到count=n-1;4.循环遍历数组a,找到最后剩下的人。
为了更加直观地展示实验结果,我们通过Python编写下述代码:```python#递归法解决约瑟夫环问题def josephus_recursive(n, m):if n == 1:return 1else:return (josephus_recursive(n - 1, m) + m - 1) % n + 1#迭代法解决约瑟夫环问题def josephus_iterative(n, m):a=[1]*ncount = 0i=0while count < n - 1:if a[i] == 1:j=0while j < m:if a[(i + j) % n] == 1:j+=1else:j=0i=(i+1)%na[(i-1)%n]=0count += 1for i in range(n):if a[i] == 1:return i + 1#测试递归法解决约瑟夫环问题print(josephus_recursive(7, 3)) # 输出4 #测试迭代法解决约瑟夫环问题print(josephus_iterative(7, 3)) # 输出4 ```通过以上代码,我们可以得到n=7,m=3时,最后剩下的人是4号人。
约瑟夫环问题 实验报告完整版
{
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;
约瑟夫环实习报告
实习报告:约瑟夫环实验一、实习背景约瑟夫环问题是一个经典的计算机科学和数学问题,起源于古罗马时期的历史故事。
问题描述了n个人围成一个圆圈,从第一个人开始报数,每数到m个人就将其删除,然后从下一个人重新开始报数,直到圈中只剩下一个人。
本实习报告旨在通过实现约瑟夫环算法,深入理解其原理和应用,并分析不同算法实现的时间和空间复杂度。
二、实习内容1. 算法实现本次实习实现了两种约瑟夫环算法的实现:迭代法和递归法。
迭代法使用循环结构模拟圆圈的过程,每轮删除指定数量的节点,直到只剩下一个节点。
递归法则利用递归函数模拟这个过程,每次递归调用删除指定数量的节点,直到只剩下一个节点。
2. 算法分析在算法分析方面,我们主要从时间复杂度和空间复杂度两个方面进行考虑。
对于迭代法,时间复杂度主要取决于删除节点的次数,每次删除操作的时间复杂度为O(1),因此总的时间复杂度为O(n)。
空间复杂度主要取决于程序的存储空间,由于使用了循环结构,空间复杂度为O(n)。
对于递归法,每次递归调用都会创建一个新的栈帧,因此空间复杂度主要取决于递归深度。
在最坏情况下,递归深度为n-1,因此空间复杂度为O(n)。
时间复杂度同样为O(n),因为每次递归调用都需要进行删除操作。
3. 实验结果我们使用Python语言实现了约瑟夫环算法,并使用Python的time模块测量了不同算法实现的时间。
实验结果显示,在n较小的情况下,迭代法和递归法的运行时间相差不大。
但随着n的增大,迭代法的运行时间逐渐优于递归法。
这是因为递归法在每次递归调用时都会创建新的栈帧,随着递归深度的增加,栈帧的创建和销毁会占用较多的时间。
三、实习心得通过本次实习,我对约瑟夫环问题有了更深入的理解。
在实现算法的过程中,我学会了如何使用循环结构和递归函数模拟圆圈的过程。
在分析算法的过程中,我学会了如何计算时间复杂度和空间复杂度,并能够根据实际情况选择合适的算法。
同时,我也认识到算法优化的重要性。
约瑟夫杯实验报告
一、实验目的1. 理解并掌握约瑟夫环问题的基本原理。
2. 通过编程实现约瑟夫环问题,加深对循环链表的理解和应用。
3. 提高数据结构与算法的设计和实现能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse三、实验原理约瑟夫环问题是一个著名的数学问题,其基本模型如下:n个人围成一圈,从第一个人开始报数,每数到m的人出列,然后下一个人继续从1开始报数,直到所有人都出列。
该问题可以用循环链表来解决。
循环链表是一种线性链表,其特点是最后一个节点的指针指向链表的头节点,形成一个环。
在约瑟夫环问题中,每个节点代表一个人,节点的指针指向下一个节点,形成一个圆圈。
四、实验步骤1. 创建一个循环链表,用于存储所有人。
2. 添加一个方法,用于模拟报数过程,并输出出列顺序。
3. 添加一个方法,用于输出所有人的编号。
五、实验代码```javapublic class JosephusCircle {// 循环链表节点static class Node {int number; // 人的编号Node next; // 指向下一个节点public Node(int number) {this.number = number;this.next = null;}}// 创建循环链表public static Node createCircle(int n) {Node head = new Node(1);Node current = head;for (int i = 2; i <= n; i++) {current.next = new Node(i);current = current.next;}current.next = head; // 形成循环return head;}// 模拟报数过程public static void simulate(int n, int m) {Node head = createCircle(n);Node current = head;Node pre = null;while (current.next != current) { // 仍有节点在链表中for (int i = 1; i < m; i++) { // 报数m-1次pre = current;current = current.next;}pre.next = current.next; // 移除当前节点System.out.println("出列:" + current.number);current = current.next; // 继续下一个节点}System.out.println("最后出列的人编号:" + current.number); }// 输出所有人编号public static void printNumbers(int n) {Node head = createCircle(n);Node current = head;System.out.print("所有人编号:");while (current.next != current) {System.out.print(current.number + " ");current = current.next;}System.out.println(current.number);}public static void main(String[] args) {int n = 10; // 人数int m = 3; // 报数simulate(n, m);printNumbers(n);}}```六、实验结果1. 当人数为10,报数为3时,出列顺序为:3 6 9 2 5 8 1 4 7 10。
约瑟夫环设计实验报告
一、实验目的1. 理解并掌握约瑟夫环问题的基本原理和解决方法。
2. 熟悉循环链表在数据结构中的应用,并能够运用其解决实际问题。
3. 提高编程能力和算法设计能力,培养逻辑思维和问题解决能力。
二、实验内容1. 实验背景约瑟夫环问题是一个经典的数学问题,描述了N个人围成一圈,按照一定的规则进行报数,最终确定出列顺序的过程。
该问题在计算机科学、通信等领域有广泛的应用。
2. 实验原理本实验采用循环链表作为数据结构来模拟约瑟夫环问题。
循环链表是一种线性表,其特点是最后一个节点的指针指向第一个节点,形成一个环。
在本实验中,我们将每个节点表示为一个人,节点的数据域存储该人的编号。
3. 实验步骤1. 初始化循环链表:首先创建一个循环链表,包含N个节点,节点编号依次为1, 2, ..., N。
2. 设置报数上限:从键盘输入一个正整数M,作为报数上限。
3. 模拟报数过程:a. 从链表头节点开始,按照顺时针方向进行报数。
b. 当报数达到M时,将当前节点出列,并将M的值设置为该节点的数据域。
c. 将指针指向下一个节点,继续进行报数。
d. 重复步骤b和c,直到链表中只剩下一个节点。
4. 输出出列顺序:按照出列的顺序,将每个节点的编号打印出来。
4. 实验代码```c#include <stdio.h>#include <stdlib.h>typedef struct Node {int number;struct Node next;} Node;// 创建循环链表Node createList(int n) {Node head = NULL, tail = NULL, temp = NULL; for (int i = 1; i <= n; i++) {temp = (Node)malloc(sizeof(Node));temp->number = i;temp->next = NULL;if (head == NULL) {head = temp;tail = temp;} else {tail->next = temp;tail = temp;}}tail->next = head; // 形成循环链表return head;}// 打印出列顺序void printOrder(Node head) {Node temp = head;while (temp->next != temp) {printf("%d ", temp->number); temp = temp->next;}printf("%d\n", temp->number);}int main() {int n, m;printf("请输入人数: ");scanf("%d", &n);printf("请输入报数上限: ");scanf("%d", &m);Node head = createList(n);printOrder(head);// 释放内存Node temp;while (head->next != head) {temp = head;head = head->next;free(temp);}free(head);return 0;}```5. 实验结果与分析通过运行实验代码,可以得到约瑟夫环问题的出列顺序。
约瑟夫环实习报告(参考)
题目:编制一个程序模拟约瑟夫问题一﹑需求分析1. 本程序将模拟约瑟夫问题,求出出列的编号,并在每次出列后显示此时的顺序,本程序采用循环链表作为存储结构,无带头结点。
2. 输入可以是文件输入或标准输入,链表长度size>0,各个结点所带的密码值secret>0,第一次的报数m>0,若m<1,将提示更正。
3. 本程序在输入完毕后将先输出刚输入的内容,再提供报数后,开始进行运算,每出列一次将显示出列者和出列后链表顺序。
4. 测试数据:长度7,密码:3,1,7,2,4,8,4,报数初值6;长度-1,密码:3,2,5,6,4;长度5,密码:3,2,5,0,4; 长度5,密码:3,2,5,6,4,报数初值-1,4。
二﹑概要设计采用循环链表表示约瑟夫环1. 循环链表的抽象定义:ADT CycList{数据对象:D={i a ,i b |i a ,i b ∈ I ,i=1,2,…3,n>0}数据关系:R={<i a ,i b >|i a ,i b ∈D,I=1,2…3}基本操作:CreatList(&L,&in)初始条件:输入流有效,输入的值合法,申请空间成功操作结果:构造一个非空的循环链表PrintList(const L)初始条件:循环链表L 已存在操作结果:输出LFun(&L,Secret)初始条件:循环链表L 已存在操作结果:得到出列顺序}2. 本程序包含两个模块:1) 主程序模块2) 循环链表模块三﹑详细设计#include <iostream>using namespace std;//每个人的号码和密码。
struct people{int NO;int pass;}node;template <class Elem>class Link{private:static Link<Elem>* freelist;//静态数据成员的头接点。
约瑟夫问题数据结构实验报告
约瑟夫问题数据结构实验报告[正文]1.实验目的本实验的目的是分析约瑟夫问题,并设计合适的数据结构解决该问题。
2.实验背景约瑟夫问题,又称为约瑟夫环,是一个经典的数学问题。
问题描述如下:有n个人围成一圈,从第一个人开始报数,数到第m个人时将其杀死,然后从下一个人开始重新报数,数到第m个人又将其杀死,如此循环进行,直到所有人都被杀死为止。
求出最后一个被杀的人在初始序列中的编号。
3.实验设计为了解决约瑟夫问题,我们需要设计合适的数据结构来表示这个过程。
以下为实验所采用的数据结构:3.1 线性表由于约瑟夫问题是围成一圈的,因此我们选择使用循环链表来表示人围成的圈。
每个节点代表一个人,包含一个成员变量用于存储人的编号。
3.2 算法采用如下算法来解决约瑟夫问题:1.创建一个循环链表,将n个人的编号分别存入节点中。
2.初始化一个指针p指向链表的第一个节点。
3.从第一个人开始报数,每报到第m个人,将该节点从链表中删除。
4.如果链表中只剩下一个节点,此时的节点即为最后一个被杀的人,输出其编号。
4.实验步骤4.1 数据结构设计根据实验设计中的描述,我们编写了一个含有循环链表和节点的数据结构。
```cppstruct ListNode {int number;ListNode next;};```4.2 实现约瑟夫问题算法根据实验设计中的算法描述,我们编写了解决约瑟夫问题的函数。
```cppint josephusProblem(int n, int m) {// 创建循环链表// 初始化指针p// 开始报数并删除节点// 返回最后被杀的人的编号}```4.3 测试与分析我们通过输入不同的n和m值,测试了约瑟夫问题的解决函数,并对实验结果进行了分析。
5.实验结果经过测试,我们得到了约瑟夫问题的解。
6.实验总结通过本实验,我们深入了解了约瑟夫问题,并成功设计了合适的数据结构和算法解决了该问题。
附件本文档无附件。
法律名词及注释1.约瑟夫问题:亦称为约瑟夫环问题,是一个数学难题,起源于古代历史记载,已有几个世纪的历史。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》
课程设计报告
课程名称:《数据结构》课程设计课程设计题目: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; /删除的是尾结点时(不知道为什么我写程序里总是编译出现错误){
q->next=head; //重新链接
delete a;
len--;
return out;
}
else
{
q->next=a->next;
delete a;
len--;
return out;
}
}
}
}
5、测试结果:
6 程序清单:
#include <>
struct LinkNode
{
int data;
int code;
LinkNode *next;
};
class LinkList
{
public:
LinkList();
void Creat(const int );
//~LinkList();
int Delete(LinkNode* );
int Joseph(int );
private:
LinkNode* head;
LinkNode* elem;
int len;
};
LinkList::LinkList()
{
head=elem=NULL;
len=0;
}
void LinkList::Creat(const int number) {
if(number==1)
{
head=elem=new LinkNode;
head->data=1;
cout<<"请输入密码:"<<endl;
cin>>head->code;
head->next=head;
}
else
{
head=elem=new LinkNode;
head->data=1;
cout<<"请依次输入各个密码:"<<endl;
cin>>head->code;
LinkNode*q=head;
q=head;
for(int i=1;i<number;i++)
{
LinkNode*p=new LinkNode;
p->data=i+1;
cin>>p->code;
q->next=p;
q=p;
}
q->next=head;
}
len=number;
}
int LinkList::Delete(LinkNode *a)
{
if(len>1)
{
if(head==a)
{
int out=head->data;
LinkNode* q=head;
while(q->next!=head)
{
q=q->next;
}
q->next=head->next;
head=head->next;
delete a;
len--;
return out;
}
else
{
LinkNode* q=head;
int out=a->data;
while(q->next!=a)
{
q=q->next;
}
q->next=a->next;
delete a;
len--;
return out;
}
}
}
int LinkList::Joseph(int m)
{
if(len>1)
{
LinkNode *q;
if(m==1)
{
q=elem;
int a=q->code;
elem=elem->next;
cout<<Delete(q)<<endl;
Joseph(a);
}
else
{
for(int i=1;i<m;i++)
elem=elem->next;
q=elem;
elem=elem->next;
int a=q->code;
cout<<Delete(q)<<endl;
Joseph(a);
}
}
else
cout<<head->data;
}
int main()
{
int num,code;
cout<<"请输入人数: ";
cin>>num;
LinkList L;
(num);
cout<<"请输入第一个上限数: ";
cin>>code;
cout<<"出列顺序:"<<endl;
(code);
return 0;
}
4、小结
一、这次课程设计的心得体会通过实践我的收获如下:
一开始接触数据结构课程设计真的挺难的,好多都不会,不是逻辑方面的问题,而是不具备动手能力,脑子里总有一团火,比如对于这个题目,一开始有很多的想法,想到了从逻辑上怎么实现他,要编写哪些程序,但是一到需要编写了就开始为难了,可以说是几乎不知道从哪里入手,参考了书本里的程序,仿照他的结构一步一步做下来,现在对于单链表的各种操作已经算是比较熟练了,让我知道光有理论知识还远远不够,需要多动手,写的多了自然就能手到擒来。
二、根据我在实习中遇到得问题,我将在以后的学习过程中注意以下几点:
1、认真上好专业实验课,多在实践中锻炼自己。
2、写程序的过程中要考虑周到,严密。
3、在做设计的时候要有信心,有耐心,切勿浮躁。
4、认真的学习课本知识,掌握课本中的知识点,并在此基础上学会灵活运用。
5、在课余时间里多写程序,熟练掌握在调试程序的过程中所遇到的常见错误,以便能节省调试程序的时间。