数据结构约瑟夫环实验报告

合集下载

约瑟夫环问题 实验报告

约瑟夫环问题 实验报告

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; } 测试用例:

数据结构:约瑟夫环实验报告

数据结构:约瑟夫环实验报告

数据结构实验报告题目:约瑟夫环姓名:学号:专业班级:指导教师:课题工作时间:一.需求分析1.约瑟夫环(Joseph)问题的一种描述是:设有编号1,2,3。

n(n>0)的N个人围成一个圈,每个人持有一个密码(正整数)。

开始时从第k(1<=k<=n)个人按顺时针方向自1开始顺序报数,报到m(m为第K个人的密码)的人出圈,再以这个人顺时针方向上的下一个人的密码为m,并开始重新从1报数。

如此下去,直至所有人全部出列为止。

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

2.演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,有用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在其后。

3.测试数据(1)m=20, n=7, 结果依次为为3,1,7,2,4,8,4(2)m=20,n=1(3)m=20,n=0前面一组为常规数据,后面两组为边缘数据二、概要设计本程序是多文件程序,构成的函数有int main() 主函数,输出出队序列int initsuiji() 随机数产生初始化int suiji(int x,int y) 随机数产生函数int InitList(SqList &L) 初始化顺序表int ListInsert(SqList &L,int i,ElemType e) 在顺序表中插入元素int ListDelete(SqList &L,int i,ElemType &e) 删除顺序表中的元素int shunxu(int number) 顺序存储算法JosephuNode *Creat_Node(int numbers) 创建单循环链表void Josephu(JosephuNode *head,int Password) 添加元素信息int lianbiao(int number) 链表算法其中,void main()是最主要的函数,分别执行两种算法,并在执行的同时按照出列顺序输出元素信息(编号,密码),并在结尾输出两种算法执行所用的时间长短。

约瑟夫环-数据结构

约瑟夫环-数据结构

实验二:Joseph(约瑟夫环)实验报告实验描述:编号为1,2,……,n的n个人按照顺时针方向围坐一圈,每个人只有一个密码(报数上限)。

任意输入一个正整数作为报数上限值k(1<=k<=n),从第一个人开始顺时针方向报数,报到k时停止报数。

报k的人出列,然后从他下一个人开始重新从1报数,如此下去,直到所有人全部出列为止。

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

实验原理:先构造一个不带头结点的单循环链表,然后定义两个节点指针,第一个指针指向第一个节点,另一个指针指向第二个节点,并且使两个节点后移,每当结点计数到某一结点时,将他的前驱结点接到他的后继结点,再将此结点删除。

如此循环,直到两个节点重合(只有一个节点)时,循环结束。

实验过程:1.基本算法以及分析:1创建结点Node链表都是由一个个结点组成,由于结点的不同,组成的链表也不同。

因此需要创建链表结点。

结点结构体如下:2建立单循环链表每当结点计数到某一结点时,将他的前驱结点接到他的后继结点,再将此结点删除。

如此循环下去,直到最后变为空的单循环链表为止。

3程序的执行过程:程序有主函数开始,首先输入创建约瑟夫环节点数以及密码(报数上限)。

然后,开始调用JosephuNode *Creat_Node函数,利用单循环链表建立起约瑟夫环,函数结尾return head; 将约瑟夫环的头指针返回,并将它赋值head,然后主函数继续调用Josephu函数,通过将head和Password引入函数,以建立两个嵌套循环输出并得到结果。

2.程序源代码:#include <stdio.h>#include <malloc.h>typedef struct Node{int Index;struct Node *next;}JosephuNode;void main(){JosephuNode *Creat_Node(int numbers);void Josephu(JosephuNode *head,int Password);int numbers, Password;JosephuNode *head;printf("\n输入约瑟夫环问题的人数和起始密码:");scanf("%d,%d", &numbers, &Password);head=Creat_Node(numbers);printf("\n输出结果如下\n");Josephu(head,Password);}JosephuNode *Creat_Node(int numbers) // 使用单循环链表创建约瑟夫环{int i,pass;JosephuNode *head, *tail;head = tail = (JosephuNode *)malloc(sizeof(JosephuNode)); //申请头结点for (i = 1; i <numbers; i++){tail->Index = i;tail->next = (JosephuNode *)malloc(sizeof(JosephuNode));tail = tail->next; //指针指向下一个结点}tail->Index = i;tail->next = head; //建立循环return head;}void Josephu(JosephuNode *head,int Password) //数据结构{int i,j;JosephuNode *rear;for (i = 1; rear != head; i++){for (j = 1; j <Password; j++){rear = head;head = head->next;}rear->next = head->next;printf("\n第%d个出局的人的编号是:%d",i,head->Index);free(head);head = rear->next;}j=head->Index;printf("\n最后一个出局的人的编号是:%d\n ",j);free(head);}。

数据结构约瑟夫环实验报告

数据结构约瑟夫环实验报告

《数据结构与算法设计》约瑟夫环实验报告——实验一专业:物联网工程班级:物联网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——约瑟夫环学生姓名:班级:班内序号:学号:日期:1.实验要求实验目的:通过利用循环链表实现约瑟夫问题的求解进行实现,掌握如下内容:1.熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法2.学习指针、模板类、异常处理的使用3.掌握线性表的操作的实现方法4.学习使用线性表解决实际问题的能力实验内容:利用循环链表实现约瑟夫问题的求解。

约瑟夫问题如下:已知n个人(n>=1)围坐一圆桌周围,从1开始顺序编号。

从序号为1的人开始报数,顺时针数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规则重复下去,直到所有人全部出列。

请问最后一个出列的人的编号。

2. 程序分析2.1 存储结构首先构建结点的结构体,包括结点的编号number和指向后继元素的指针*next。

然后构建循环链表储存每一个结点。

2.2 关键算法分析1、关键算法:插入:用尾插法构建循环链表,建立一个尾指针r用来保存最后一个结点的地址,插入每一个节点后,r指向新插入的结点。

用for循环来给每一个结点的number赋值。

插入的步骤:1.建立新指针s;2.在for循环中给s赋值;3.将r指针指向s;4.修改尾指针r=s5.在全部结点插入后,将终端结点指向第一个指针,r->next=front->next。

约瑟夫环算法实现:1.因为每次循环都有一个人出列,最后只剩一个人,因此要进行n-1次循环,用for循环实现。

2.同时定义一个指针p=front->next,每次循环front和p均后移m-1个,使p指向每次循环的第m个人,front指向第m-1个人。

并输出出列的人的number,即p->number。

3.让front->next=p->next,删除p。

4.继续进行循环2、代码详细分析:约瑟夫环算法步骤:①定义一个指针p=front->next,每次循环front和p均后移m-1个,使p指向每次循环的第m个人,front指向第m-1个人。

约瑟夫环数据结构实验报告

约瑟夫环数据结构实验报告

约瑟夫环数据结构实验报告《约瑟夫环数据结构实验报告》摘要:本实验旨在通过使用约瑟夫环数据结构来模拟约瑟夫问题,并通过实验结果分析该数据结构的性能和适用场景。

实验结果表明,约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率,并且可以应用于一定范围的实际问题中。

1. 引言约瑟夫问题是一个经典的数学问题,描述了一个有n个人的圆桌围坐,从第一个人开始报数,报到m的人离开,然后从离开的人的下一个人开始重新报数,直到所有人离开。

在本实验中,我们将使用约瑟夫环数据结构来模拟这一问题,并分析其性能和适用场景。

2. 实验方法我们首先定义了一个约瑟夫环的数据结构,并实现了相应的插入、删除等操作。

然后,我们使用不同规模的数据集进行了实验,记录了每次操作的时间开销,并进行了性能分析。

3. 实验结果实验结果表明,约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率。

在不同规模的数据集下,其操作时间基本保持在可接受的范围内,并且随着数据规模的增加,性能表现基本保持稳定。

4. 结论约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率,并且可以应用于一定范围的实际问题中。

然而,在处理大规模数据时,仍需进一步优化算法和数据结构,以提高性能和效率。

5. 展望未来,我们将进一步研究约瑟夫环数据结构在实际问题中的应用,并探索其在其他领域的潜在价值。

同时,我们也将继续优化算法和数据结构,以提高其性能和适用范围。

综上所述,约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率,并且具有一定的实际应用价值。

通过本实验,我们对该数据结构有了更深入的了解,并为其在实际问题中的应用提供了一定的参考和借鉴。

约瑟夫环数据结构实验报告

约瑟夫环数据结构实验报告

约瑟夫环数据结构实验报告约瑟夫环数据结构实验报告引言约瑟夫环是一种经典的数学问题,它涉及到一个有趣的数据结构。

本次实验旨在通过实现约瑟夫环数据结构,深入理解该问题,并探索其在实际应用中的潜力。

本报告将介绍实验的设计和实现过程,并分析实验结果。

实验设计在本次实验中,我们选择使用链表来实现约瑟夫环数据结构。

链表是一种非常灵活的数据结构,适合用于解决约瑟夫环问题。

我们设计了一个Josephus类,其中包含了创建环、添加元素、删除元素等操作。

实验实现1. 创建环在Josephus类中,我们首先需要创建一个循环链表。

我们使用一个头节点来表示环的起始位置。

在创建环的过程中,我们可以选择指定环的长度和起始位置。

2. 添加元素在创建环之后,我们可以通过添加元素来向约瑟夫环中插入数据。

我们可以选择在环的任意位置插入元素,并且可以动态地调整环的长度。

3. 删除元素根据约瑟夫环的规则,每次删除一个元素后,下一个元素将成为新的起始位置。

我们可以通过删除元素的操作来模拟约瑟夫环的运行过程。

在删除元素时,我们需要考虑环的长度和当前位置。

实验结果通过实验,我们得出了以下结论:1. 约瑟夫环数据结构可以有效地模拟约瑟夫环问题。

通过创建环、添加元素和删除元素的操作,我们可以模拟出约瑟夫环的运行过程,并得到最后剩下的元素。

2. 约瑟夫环数据结构具有一定的应用潜力。

除了解决约瑟夫环问题,该数据结构还可以用于其他类似的问题,如任务调度、进程管理等。

3. 约瑟夫环数据结构的时间复杂度较低。

由于约瑟夫环的特殊性质,我们可以通过简单的链表操作来实现该数据结构,使得其时间复杂度较低。

结论本次实验通过实现约瑟夫环数据结构,深入理解了该问题,并探索了其在实际应用中的潜力。

通过创建环、添加元素和删除元素的操作,我们可以模拟出约瑟夫环的运行过程,并得到最后剩下的元素。

约瑟夫环数据结构具有一定的应用潜力,并且具有较低的时间复杂度。

通过本次实验,我们对数据结构的设计和实现有了更深入的理解,并为将来的研究和应用奠定了基础。

数据结构约瑟夫环实习报告

数据结构约瑟夫环实习报告

数据结构约瑟夫环实习报告一、实习题目约瑟夫环(Josephus Problem)是一种经典的问题,编号为1,2,……,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。

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

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

试设计一个程序求出出列顺序,并利用单向循环链表存储结构模拟此过程,按照出列的顺序输出各人的编号。

二、实习目的1. 熟悉单向循环链表的存储结构及其应用。

2. 加深对线性链表这种数据结构的基本概念理解。

3. 锻炼较强的思维和动手能力,更加了解编程思想和编程技巧。

三、实习内容1. 采用单向循环链表实现约瑟夫环。

2. 从键盘输入整数m,通过create函数生成一个具有m个结点的单向循环链表。

3. 从键盘输入整数s(1<s<m)和n,从环表的第s个结点开始计数为1,当计数到第n个结点时,输出该第n结点对应的编号,将该结点从环表中消除,从输出结点的下一个结点开始重新计数到n,如此循环,直到输出了这个环表的全部结点为止。

四、程序设计1. 概要设计为了解决约瑟夫环的问题,我们可以建立单向循环链表来存储每个人的信息(该人的编号以及其下一个人的编号),及结点,人后通过查找每个结点,完成相应的操作来解决约瑟夫问题。

抽象数据类型定义:数据对象:D数据关系:R1基本操作:操作结果:构造2. 详细设计(1)初始化循环单链表```cvoid initList(LNode *head) {head->next = head;head->number = 0;}```(2)尾插法建立循环单链表```cvoid createFromTail(LNode *head, int m, int pass, int length) { LNode *p = head;int i;for (i = 1; i <= m; i++) {LNode *s = (LNode *)malloc(sizeof(LNode));s->number = i;s->pass = pass;s->next = NULL;p->next = s;p = s;}p->next = head; // 使链表形成一个环}```(3)从链表中删除结点```cvoid deleteFromList(LNode *head, LNode *p) {if (p->next == head) { // 删除的是头结点head = p->next;}p->next = p->next->next;free(p);}```(4)约瑟夫计数```cvoid yuesefu(LNode *head, int m, int n, int *sequence) { int count = 0;LNode *p = head;while (p->next != p) { // 当链表中还有多个结点时循环 count = 0;LNode *q = p->next;while (count < n) {q = q->next;count++;}sequence[count] = q->number; // 记录下出列的人的编号deleteFromList(head, q); // 删除该结点p = q->next; // 从下一个结点又开始计算n = m; // 新的M值}}```五、实验结果与分析通过以上程序设计,我们可以得到约瑟夫环的出列顺序。

数据结构实验报告_约瑟夫环

数据结构实验报告_约瑟夫环
using namespace std;
typedef struct Node
{
int num;
int key;
struct Node *next;
}Node,*LinkList;
void main()
{
int n,m;
cout<<"请输入人数:";
cin>>n;
while(n<=0){
cout<<"人数不合法,请重新输入:";
{
cout<<p->num<<"号的密钥为"<<p->key<<endl;
p=p->next;
}
cout<<endl;
for(i=1;i<=n;i++)
{
for(int k=1;k<m;k++)
p=p->next;
q=p->next;
m=q->key;
cout<<"第"<<i<<"个出列的是"<<q->num<<"号"<<endl;
数据结构实验
题目:约瑟夫环
一、问题描述
用循环单链表实现约瑟夫环。
二、概要设计及存储表示
建立不带头结点的循环单链表,通过循环语句实现结点指针的传递及结点的删除,并输出删除的节点顺序。
每个结点分别存储一个序号及一个密钥两个变量,以及指向下一结点的指针。
三、调试分析
1.结点建立时发现错误,忘记结点应存储两个数据。

数据结构实验报告(杨辉三角-约瑟夫环)

数据结构实验报告(杨辉三角-约瑟夫环)

数据结构实验报告实验一杨辉三角形(Pascal’s triangle)一、需求分析1.输入的形式和输入值的范围本程序中,需输入的杨辉三角级数level为正整数,由键盘输入,以回车结束2.输出的形式通过屏幕输出杨辉三角3.程序所能达到的功能用户从键盘输入需要的杨辉三角级数,从屏幕输出杨辉三角4.测试数据输入:5输出: 1 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1二、概要设计以链队列结构实现该实验1.抽象数据类型定义ADT Queue {数据对象:D = { ai | ai∈ElemSet , i = 1,2,…,n,n≥0 }数据关系:R1={<ai-1,ai> | ai-1 , ai∈D, i=2,…,n}约定其中ai端为队列头,an端为队列尾基本操作:InitQueue ( &Q )操作结果:构造一个空队列QDestroyQueue ( &Q )初始条件:队列Q已存在操作结果:队列Q被销毁,不再存在ClearQueue ( &Q )初始条件:队列Q已存在操作结果:将Q清为空队列QueueEmpty ( Q )初始条件:队列Q已存在操作结果:若Q为空队列,则返回TRUE,否则FALSEQueueLength ( Q )初始条件:队列Q已存在操作结果:返回Q的元素个数,即队列长度GetHead ( Q , &e )初始条件:Q为非空队列操作结果:用e返回Q的队头元素EnQueue ( &Q , e )初始条件:队列Q已存在操作结果:插入元素e为Q的新队尾元素DeQueue ( &Q , &e )初始条件:Q为非空队列操作结果:删除Q的队头元素,并用e返回其值QueueTraverse ( Q , visit( ) )初始条件:Q已存在且非空操作结果:从队头到队尾,依次对Q的每个数据元素调用函数visit( )。

数据结构实验报告—约瑟夫问题求解

数据结构实验报告—约瑟夫问题求解

数据结构实验报告—约瑟夫问题求解《计算机软件技术基础》实验报告 I —数据结构实验一、约瑟夫斯问题求解一、问题描述1.实验题目:编号 1,2,....,n的n个人顺时针围坐一圈,每人持有一个密码(正整数)。

开始选择一个正整数作为报数上限m,从第一个人开始顺时针自1 报数,报到m的人出列,将他的密码作为新的m值,从他在顺时针方向下一个人开始重新从 1 报数,直至所有人全部出列。

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

3. 测试数据: n=7,7 个人的密码依次为:3,1,7,2,4,8,4.m初值为6(正确的出列顺序应为 6,1,4,77,2,3)。

二、需求分析1. 本程序所能达到的基本可能:该程序基于循环链表来解决约瑟夫问题。

用循环链表来模拟n 个人围坐一圈,用链表中的每一个结点代表一个人和他所代表的密码。

在输入初始密码后m,对该链表进行遍历,直到第 m个结点,令该结点的密码值作为新的密码值,后删除该结点。

重复上述过程,直至所有的结点被释放空间出列。

2. 输入输出形式及输入值范围:程序运行后提示用户输入总人数。

输入人数n 后,程序显示提示信息,提示用户输入第i个人的密码,在输入达到预定次数后自动跳出该循环。

程序显示提示信息,提示用户输入初始密码,密码须为正整数且不大于总人数。

3.输出形式提示用户输入初始密码,程序执行结束后会输出相应的出列结点的顺序,亦即其编号。

用户输入完毕后,程序自动运行输出运行结果。

4.测试数据要求:测试数据 n=7,7 个人的密码依次为:3, 1, 7, 2, 4, 8,4。

m初值为 6(正确的出列顺序应为6, 1, 4,7, 2, 3, 5)。

三、概要设计为了实现上述功能,应用循环链表来模拟该过程,用结构体来存放其相应的编号和密码信息,因此需要循环链表结构体这个抽象数据类型。

1.循环链表结构体抽象数据类型定义:ADT Node{数据对象:D={ai,bi,ci|ai∈ int,bi ∈ int,ci∈(Node*),i=1,2...,n,n ≥0}:数据关系: R=?基本操作:CreatList(int n)// Order(int m,node *l)}ADT node;构建循环单链表;// 输出函数,输出出列顺序并删除链表中的结点;2.ADT 的 C 语言形式说明:typedef struct Node{int num;//结点的数据域,存放编号;int word; //结点的数据域,存放密码;struct Node *next; //结点的指针域,存放指向下一结点的指针;}Node;Node *CreatList( )// 建立循环单项链表;void Order(Node *h) //输出出列顺序并删除结点;3.主程序流程及其模块调用关系:1) . 主程序流程:先提示用户输入相关数据:总人数,运行循环链表结构体模块,输入每个人持有的密码值,创建出新链表,运行输出函数模块,再输入初始密码m值,输出出列序列。

约瑟夫问题实验报告

约瑟夫问题实验报告

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

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

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

数据结构实验报告约瑟夫环

数据结构实验报告约瑟夫环

数据结构实验报告约瑟夫环约瑟夫环是一个经典的问题,涉及到数据结构中的循环链表。

在本次数据结构实验中,我们将学习如何使用循环链表来解决约瑟夫环问题。

约瑟夫环问题最早出现在古代,传说中的犹太历史学家约瑟夫斯·弗拉维奥(Josephus Flavius)在围攻耶路撒冷时,为了避免被罗马人俘虏,与其他39名犹太人躲进一个洞穴中。

他们决定宁愿自杀,也不愿被敌人俘虏。

于是,他们排成一个圆圈,从第一个人开始,每次数到第七个人,就将他杀死。

最后剩下的人将获得自由。

在这个问题中,我们需要实现一个循环链表,其中每个节点表示一个人。

我们可以使用一个整数来表示每个人的编号。

首先,我们需要创建一个循环链表,并将所有人的编号依次添加到链表中。

接下来,我们需要使用一个循环来模拟每次数到第七个人的过程。

我们可以使用一个指针来指向当前节点,然后将指针移动到下一个节点,直到数到第七个人为止。

一旦数到第七个人,我们就将该节点从链表中删除,并记录下该节点的编号。

然后,我们继续从下一个节点开始数数,直到只剩下一个节点为止。

在实现这个算法时,我们可以使用一个循环链表的数据结构来表示约瑟夫环。

循环链表是一种特殊的链表,其中最后一个节点的指针指向第一个节点。

这样,我们就可以实现循环遍历链表的功能。

在实验中,我们可以使用C语言来实现循环链表和约瑟夫环算法。

首先,我们需要定义一个节点结构体,其中包含一个整数字段用于存储编号,以及一个指针字段用于指向下一个节点。

然后,我们可以实现创建链表、添加节点、删除节点等基本操作。

接下来,我们可以编写一个函数来实现约瑟夫环算法。

该函数接受两个参数,分别是参与游戏的人数和每次数到第几个人。

在函数内部,我们可以创建一个循环链表,并将所有人的编号添加到链表中。

然后,我们可以使用一个循环来模拟每次数到第几个人的过程,直到只剩下一个节点为止。

在每次数到第几个人时,我们可以删除该节点,并记录下其编号。

最后,我们可以返回最后剩下的节点的编号。

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

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

实验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)算法的基本思想:约瑟夫环问题中的数据是人所在的位置,而这种数据是存在“第一元素、最后元素”,并且存在“唯一的前驱和后继的”,符合线性表的特点。

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

约瑟夫环问题 实验报告完整版
建立模型,确定存储结构。
对任意 n 个人,密码为 m,实现约瑟夫环问题。 出圈的顺序可以依次输出,也可以用一个数组存储。
(3)思考: 采用顺序存储结构如何实现约瑟夫环问题
如果每个人持有的密码不同,应如何实现约瑟夫环问题
2.数据结构设计
由于约瑟夫环问题本身具有循环性质,考虑采用循环链表,为了统一对表中 任意结点的操作,循环链表不带头结点。将循环链表的结点定义为如下结构类型:
实验报告
实验课名称:数据结构实验一
实验名称:约瑟夫环问题
班级 000
学号 000
姓 名 神 刀 公 时间 子
1.问题描述
约瑟夫环问题
(1)问题描述 设有编号为 1,2,…,n 的 n(n>0)个人围成一个圈,每个人持有一个密码 m。 从第一个人开始报数,报到 m 时停止报数,报 m 的人出圈,再从他的下一个人 起重新报数,报到 m 时停止报数,报 m 的出圈,……,如此下去,直到所有人全 部出圈为止。当任意给定 n 和 m 后,设计算法求 n 个人出圈的次序。 (2)基本要求
4.界面设计
程序无需复杂的界面设计,包含输入提示功能和输出提示功能。
5.运行测试与分析
(1)输出提示 ,如图所示。
(2)根据提示,输入圈内人数 n 和每个人持有的密码 m 如图所示。
(3)输出结果如图所示
分析 6.实验收获及思考
通过该实验,我进一步增强了对于链表的理解,也对链表的操作和实现更为熟 悉,熟练掌握了如何实现置空表、求表的长度、取结点、定位运算、插入运算、 删除运算、建立不带头结点的单链表(头插入法建表)、建立带头结点的单链表 (尾插入法建表),输出带头结点的单链表等操作。同时,锻炼了实际操作时的 动手能力。
struct Node {

约瑟夫环设计实验报告

约瑟夫环设计实验报告

一、实验目的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.实验背景约瑟夫问题,又称为约瑟夫环,是一个经典的数学问题。

问题描述如下:有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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《数据结构》课程实验报告书
姓名:_____**_________
学号:____**********____
专业:____物联网工程____
班级:_____1604________
2017 年 10 月 15 日
一、实验目的
1.掌握线性表特性
2.熟练掌握线性表的基本操作
3. 利用线性表设计算法并实现
二、实验内容
1.解决约瑟夫环问题:已知n 个人(以编号1,2,3...n 分别表示)围坐在一张圆桌周围。

从编号为k 的人开始报数,数到m 的那个人出列;他的下一个人又从1开始报数,数到m 的那个人又出列;依此规律重复下去,直到圆桌周围的人全部出列。

2.基本要求:1)根据题目要求设计解决约瑟夫环应用问题的数据结构。

2)要求采用C++编程语言实现设计的算法。

三、设计思路
1.
可将人的顺序简单编号,从1到n ;
构造一个循环链表,可以解决首位相连的问题;
将人的编号插入到结构体的
Data 域中; 遍历人的编号,输出参与的人的编号;
开始报数,从头报数,报到k 的人出局(删除此结点),并释放此结点。

直到人数只有一个人时,退出循环,输出获胜的人。

2.存储结构设计
(循环结束条件)
3.算法的核心思想说明
确定需要删除的位置;
设置并删除该位置。

已知报数间隔m,我们可以把当前位置加上m获得需要删除的位置,如果获得的位置超过顺序表中实际元素的总长度,则可以通过减去数组的实际长度来修正修正(即模拟环状计数)。

然后把顺序表中的当前指向位置设置为该位置,继而删掉该位置。

反复进行上述确定位置和删除位置的操作,直到顺序表为空。

四、数据结构设计
1.类的声明和定义(要求给出完整的类声明和核心成员函数的定义)
#ifndef Joseph_H
#define Joseph_H
#include<iostream>
using namespace std;
struct Node//结点
{
int data;//存储数据
Node *next;//下一个节点的地址
};
class CircularLinkList//单向循环链表类
{
public:
CircularLinkList()//构造函数
{
first = new Node;
first->data = NULL;
first->next = first;
}
~CircularLinkList() { delete first; }//析构函数
void CreateLinkList(int a[], int n); //创建单向循环链表
void PrintLinkList(); //遍历链表
void Joseph(int k,int n); //约瑟夫环实现
private:
Node *first;
};
#endif
2.算法实现
#include"Joseph.h"
#include<windows.h>
#include<iomanip>
void CircularLinkList::CreateLinkList(int a[], int n)
{
Node *s, *r = first;//尾指针初始化
for (int i = 0;i < n;i++)//尾插法
{
s = new Node;
s->data = a[i];
r->next = s;
r = s;
}
r->next = first->next;//循环
}
void CircularLinkList::PrintLinkList()
{
int count = 0;//计数器
Node *r = first->next;
do {
cout <<setw(3)<< r->data;
count++;
r = r->next;
if (count % 10 == 0)
cout << endl<<" ";
} while (r != first->next);//当链表循环到第一节点时跳出循环
cout << endl;
}
void CircularLinkList::Joseph(int k,int n)
{
int m;
cout <<" -->>请输入约瑟夫密码:" ;
cin >> m;//输入约瑟夫密码
Node *pre, *p;
pre = first;//工作指针初始化
p = pre->next;
for (int i = 0;i < k-1;i++)
{
pre = pre->next;
p = pre->next;
}
int count = 1;//计数器初始化,约瑟夫问题至少有两个成员
cout <<" ***************************************************\n";
while (pre != p)
{
if (count == m)//如果计数器等于密码
{
Sleep(1 * 1000);//执行挂起一段时间(1秒)
cout <<setw(26)<< p->data <<"号死亡!"<< endl;//显示结果
Node *q = p;
pre->next = p->next;
delete q;//删除死亡结点
p = pre->next;
count = 1;//计数器重新计数
}
else
{
pre = pre->next;//工作指针后移
p = p->next;
count++;//计数器加一
}
}
cout <<" ***************************************************\n";
cout <<setw(26)<< p->data <<"号存活!"<< endl;//显示最后存活的
delete p;//删除结点p
system("pause");
}
五、程序测试与实现
1.程序在调试过程中出现的问题及解决办法
2.程序运行过程及结果界面
六、实验调试
七、问题及解决方法
问题:无法从第k个人开始报数。

解决方法:用while循环,找寻开始报数的编号k,找到后把他报的数标记为1. 问题:将LinkList.h文件的LinkList类中的行为函数放进LinkList.cpp文件中出现错误“重定义”。

解决办法:将行为函数的定义与声明均放进LinkList.h文件中。

八、心得体会
通过对约瑟夫环问题算法的设计,我加深了对数据结构及存储结构的理解,进一步的理解了课本中所学的各种数据结构,尤其是对单链表上基本运算的体现,学会了如何使用循环链表,比如建立一个循环链表,删除链表中的一个结点,增加一个结点等等。

另外,写代码一定要细心仔细,不能犯不该犯的粗心的错误!
注(格式要求):1)字体采用楷书小四号字,行间距为固定值20磅
2)代码用Time New Roman字号为五号,行间距固定值16磅。

相关文档
最新文档