约瑟夫环实验报告

合集下载

约瑟夫环实验报告

约瑟夫环实验报告

约瑟夫环实验报告约瑟夫环是一个经典的数学问题,它涉及到一个有趣的游戏。

这个游戏的规则是:有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)掌握线性表的链式存储结构的应用。

二、实验内容与实验步骤(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)主要的函数或操作内部的主要算法,分析这个算法的时、空复杂度,并说明设计的巧班级:学号:姓名:组号:实验成绩:批阅教师签字:实验日期:实验时间:妙之处。

约瑟夫环问题实验报告

约瑟夫环问题实验报告

约瑟夫问题实验报告背景约瑟夫问题(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个数输出到屏幕上三.详细设计首先,设计实现约瑟夫环问题的存储结构。

实验报告 约瑟夫问题

实验报告 约瑟夫问题
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;
}
实验中遇到的问题及解决方法
实验结果如下:
实验总结(结果和心得体会)

约瑟夫环实验报告

约瑟夫环实验报告

约瑟夫环问题实验报告一、实验内容本实验利用单向循环链表模拟约瑟夫环问题(编号为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;后,问题解决。

约瑟夫环-数据结构

约瑟夫环-数据结构

数据结构期末试验报告学院:专业:学号:班级:姓名:2010.12.12 Joseph约瑟夫环上机实验报告实验名称:joseph约瑟夫环题目要求的约瑟夫环操作:编号是1,2,……,n的n个人按照顺时针方向围坐一圈,每个人只有一个密码(正整数)。

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

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

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

实验要求:1~)利用单向循环链表存储结构模拟此过程,按照出列的顺序输出各个人的编号。

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

3~)建立一个输出函数,将正确的输出序列4~)测试数据:m的初值为20,n=7 ,7个人的密码依次为3,1,7,2,4,7,4,首先m=6,则正确的输出是什么?实验过程:1.基本算法以及分析:本程序主要是以建立单循环链表的形式,建立起一个约瑟夫环,然后根据之前创立的结点,输入结点里的一些数据,如下typedef struct Node{int Index; 在当前环中所处的位置,即编号int Password; 在当前环中的所带的密码struct Node *next;}JosephuNode;程序有主函数开始,首先,提示输入创建约瑟夫环环数以及每个环上所带的密码。

然后,开始调用JosephuNode *Creat_Node函数,利用单循环链表建立起约瑟夫环,tail->next = head;就是将最后一个结点的后继指向头结点,函数结尾return head; 将约瑟夫环的头指针返回,并将它赋值head,然后主函数继续调用Josephu函数,通过讲head和Password 引入函数,以建立两个嵌套循环输出并实现如下功能:编号是1,2,……,n的n个人按照顺时针方向围坐一圈,每个人只有一个密码(正整数)。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

约瑟夫环 实验报告

约瑟夫环 实验报告

约瑟夫环实验报告约瑟夫环实验报告引言:约瑟夫环是一个经典的数学问题,它源自于古代传说。

根据传说,古代犹太人被罗马人围困在一个洞穴中,他们决定用一种特殊的方式来决定谁将成为首领。

他们站成一个圆圈,从一个人开始,每隔一个人杀掉一个,直到只剩下一个人。

这个问题被称为约瑟夫环问题,它在数学领域引起了广泛的研究和探讨。

实验目的:本实验旨在通过模拟约瑟夫环问题,探讨其数学规律和解法,并分析实验结果的意义和应用。

实验步骤: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无关。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

约瑟夫实验报告

约瑟夫实验报告

约瑟夫实验报告约瑟夫实验报告约瑟夫实验是一个古老而有趣的数学问题,它源自于古代罗马的历史。

约瑟夫问题的描述是:有n个人围成一个圆圈,从某个人开始,依次报数,每报到第m个人,就将该人从圈中移除,然后从下一个人开始重新报数。

如此循环,直到只剩下最后一个人。

那么,最后剩下的人是谁呢?这个问题看似简单,但实际上却涉及到一些有趣的数学原理。

为了解决这个问题,我们可以通过模拟实验来观察和分析。

在这个实验中,我们选择了一组有限的人数,并设定了一个固定的报数值。

首先,我们选择了一个较小的n值,比如说10。

接下来,我们设定m的值为3。

然后,我们按照约瑟夫问题的规则进行模拟实验。

实验开始时,我们将10个人围成一个圆圈,从第一个人开始报数。

当报到第3个人时,这个人将从圈中移除。

然后,从下一个人开始重新报数。

我们重复这个过程,直到只剩下最后一个人。

通过观察实验结果,我们发现,在这个特定的情况下,最后剩下的人是第4个人。

这个结果似乎有些出人意料,因为我们可能会认为最后剩下的人应该是圈中的某个固定位置。

然而,事实并非如此,最后剩下的人的位置是不确定的,它取决于n和m的值。

为了进一步探究这个问题,我们可以改变n和m的值,观察它们对最后剩下的人的影响。

当n增大时,我们发现最后剩下的人的位置也会随之变化。

而当m的值增大时,最后剩下的人的位置也会发生变化。

这个实验告诉我们,约瑟夫问题并没有一个固定的答案,而是取决于初始条件。

而这种变化的规律则可以通过数学方法进行推导和证明。

通过数学推导,我们可以得出一个结论:对于任意给定的n和m值,最后剩下的人的位置可以用一个数学公式来表示。

这个公式是一个递推公式,它可以通过递归的方式来求解。

通过这个公式,我们可以快速计算出最后剩下的人的位置,而无需进行大量的模拟实验。

约瑟夫实验不仅仅是一个有趣的数学问题,它还有着深刻的数学原理。

通过这个问题,我们可以学习到递推公式的应用,以及如何通过数学方法来解决实际问题。

约瑟夫环实验报告

约瑟夫环实验报告

约瑟夫环实验报告约瑟夫环(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号人。

约瑟夫环实验报告

约瑟夫环实验报告

约瑟夫环实验报告约瑟夫环实验报告约瑟夫环是一种古老而有趣的数学问题,它源于古代传说中的一个故事。

根据这个故事,约瑟夫是一位犹太人,他和他的朋友们被罗马军队包围在了一个洞穴中。

他们决定宁愿死在洞穴里,也不愿被捕。

于是,他们决定通过一个特殊的方式来决定谁将是第一个自愿去死的人。

约瑟夫提出了一个规则:所有人围成一个圆圈,从某个人开始,每次数到一个固定的数字,该人就会被移除。

然后,继续数下去,直到只剩下一个人。

这个问题被称为约瑟夫环。

为了更好地理解这个问题,我们进行了一次约瑟夫环实验。

我们邀请了十个志愿者参与实验。

首先,我们让他们围成一个圆圈,按照顺时针方向依次编号为1到10。

然后,我们决定每次数到3的人将被移除。

实验开始后不久,我们就发现了一些有趣的现象。

首先,当数到第三个人时,他被移除了。

然后,我们继续数下去,每次数到第三个人,他们也被移除。

但是,当我们数到第九个人时,他并没有被移除。

相反,我们又从第一个人开始数。

这个过程一直持续下去,直到只剩下最后一个人。

通过这个实验,我们发现了约瑟夫环问题的一些规律。

首先,当总人数为奇数时,最后剩下的人的编号总是1。

这是因为每次移除一个人后,剩下的人重新排列,而编号为1的人始终在最后一个位置。

而当总人数为偶数时,最后剩下的人的编号取决于每次数到的数字。

例如,在我们的实验中,当总人数为10时,最后剩下的人的编号是5。

除了这些规律,约瑟夫环问题还有一些有趣的数学性质。

例如,我们可以通过数学推导得出,当总人数为2的幂次方时,最后剩下的人的编号总是1。

这是因为在每次移除一个人后,剩下的人的编号都会向前移动一个位置,而编号为1的人始终在最后一个位置。

通过这次实验,我们不仅更深入地了解了约瑟夫环问题,还发现了一些有趣的数学规律。

这个问题不仅仅是一个数学谜题,它也可以引发我们对数学的思考和探索。

我们相信,通过继续研究约瑟夫环问题,我们可以发现更多有趣的数学性质和规律。

总结起来,约瑟夫环是一个古老而有趣的数学问题,通过实验我们发现了一些规律和性质。

约瑟夫环(Joseph)实验报告

约瑟夫环(Joseph)实验报告

一.需求分析1.约瑟夫环(Joseph)问题的一种描述是:设有编号1,2,3。

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

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

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

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

3.测试数据(1)m=20, n=7, 7个人的密码依次为:3,1,7,2,4,8,4结果:6,1,4,7,2,3,5二、概要设计本程序是多文件程序,构成的函数有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()是最主要的函数,分别执行两种算法,并在执行的同时按照出列顺序输出元素信息(编号,密码),并在结尾输出两种算法执行所用的时间长短。

三、详细设计#include<stdio.h>#include<malloc.h>typedef struct node{int num,code;struct node *next;}Lnode, *LinkList;Lnode *Create_L(LinkList L,int n){int i,key;Lnode *p,*s;p = L;for(i = 1;i <= n;i ++){printf("输入第%d人",i);printf(" 密码:");scanf("%d",&key);s = (Lnode *)malloc(sizeof(Lnode));p->next = s;p = s;p->num = i;p->code = key;}p->next = L->next;p = L;L = L->next;free(p);return L;}void Output_L(LinkList L,int m, int n) {int i,j,key;Lnode *p,*s;key = m;do{p = L;j = 1;if(key == 1){i = p->num;key = p->code;printf("第%d人",i);s = p->next;while(s->next != L)s = s->next;s->next = p->next;L = p->next;free(p);n --;}else{while(j < key){s = p;p = p->next;j ++;}i = p->num;key = p->code;printf("第%d人",i);s->next = p->next;L = p->next;free(p);n --;}}while(n > 0);}int main(){int n,m;Lnode *L;L = (Lnode *)malloc(sizeof(Lnode));printf("输入参加的人数:");scanf("%d",&n);if(n < 0){printf("输入数据不合理,请重新输入。

约瑟夫实验报告

约瑟夫实验报告

约瑟夫实验报告约瑟夫实验报告约瑟夫实验是一个经典的数学问题,它以约瑟夫斯·弗拉维奥(Josephus Flavius)的名字命名。

约瑟夫是一位古罗马时期的犹太历史学家和将军,他在犹太战争中被困在了一个洞穴里。

为了避免被敌人俘获,他和其他39名战士决定进行一项实验。

实验的规则是这样的:40个人站成一个圆圈,每个人都有一个编号,从1到40。

开始时,约瑟夫被指定为第一个被杀的人,而剩下的人依次按照顺时针方向报数,报数到3的人将被杀死。

然后,从下一个人开始,继续按照同样的规则进行报数,直到只剩下一个人为止。

这个问题的关键在于找到最后一个存活的人的编号。

我们可以通过编写一个简单的程序来解决这个问题。

首先,我们需要创建一个循环链表,其中每个节点都包含一个编号。

然后,我们可以使用一个循环来模拟报数的过程,并在每次报数到3时删除相应的节点。

最后,当链表中只剩下一个节点时,该节点的编号就是最后一个存活的人的编号。

通过对这个问题进行实验,我们可以得出一些有趣的结论。

首先,我们发现无论圆圈中的人数是多少,最后一个存活的人的编号总是1。

这是因为每次删除节点后,剩下的节点会重新排列,而最后一个节点的编号总是1。

其次,我们还发现当圆圈中的人数是2的幂次方时,最后一个存活的人的编号总是2。

这是因为每次删除节点后,剩下的节点会按照一定的规律重新排列,而最后一个节点的编号总是2的幂次方。

这个问题还可以引申出一些其他的数学问题。

例如,我们可以考虑每次报数的步长不是3,而是其他的数字。

我们可以通过修改程序中的报数规则来解决这个问题。

另外,我们还可以考虑圆圈中的人数不是固定的,而是一个变量。

我们可以通过修改程序中的链表长度来解决这个问题。

除了数学问题,约瑟夫实验还可以引发一些关于人性和生存的思考。

在这个实验中,每个人都面临着生与死的抉择。

他们必须决定是坚持到最后,还是在某个时刻选择自杀。

这个实验可以让我们思考人类对生命的珍视和对自身利益的权衡。

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

约瑟夫环问题 实验报告完整版
建立模型,确定存储结构。
对任意 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 {

最新实验一约瑟夫问题实验报告

最新实验一约瑟夫问题实验报告

最新实验一约瑟夫问题实验报告实验目的:探究约瑟夫问题(Josephus Problem)的数学规律及其在不同参数下的表现,验证相关算法的效率和准确性。

实验背景:约瑟夫问题是一个著名的理论问题,源自于罗马时代的一个传说。

问题可以描述为:n个人围成一圈,从第一个人开始报数,每数到第m个人,该人出圈,然后从下一个人重新开始报数,如此循环,直到所有人出圈。

本实验旨在通过编程模拟这一过程,并分析结果。

实验方法:1. 采用编程语言(如Python)编写约瑟夫问题的模拟程序。

2. 设定不同的n和m值,运行程序,记录每个人的出圈顺序及最后剩下的人的位置。

3. 分析不同n和m值下的出圈顺序规律。

4. 对比不同算法(如递归法、迭代法)的运行时间,评估效率。

实验步骤:1. 初始化参数:确定模拟的总人数n和报数间隔m。

2. 创建一个循环队列模拟人们围成的圈。

3. 通过循环和条件判断模拟报数和出圈过程。

4. 记录每次出圈的人的编号和最终剩下的人的位置。

5. 改变n和m的值,重复步骤1至4,收集多组数据。

6. 分析数据,寻找出圈规律。

7. 对模拟过程进行计时,比较不同算法的运行时间。

实验结果:1. 通过大量实验数据,发现当n和m的值较小时,可以直观看出出圈顺序的规律。

2. 随着n和m值的增大,出圈顺序变得更加复杂,但依然存在一定的规律性。

3. 实验中使用的迭代法在处理大规模数据时,相比递归法具有更高的效率,递归法在深度较大时可能会导致栈溢出。

4. 通过图表展示了不同n和m值下,最后剩下的人的位置的概率分布。

实验结论:1. 约瑟夫问题的出圈顺序并非完全随机,存在一定的数学规律。

2. 迭代法在解决大规模约瑟夫问题时更为高效和稳定。

3. 本实验为进一步研究约瑟夫问题提供了实验数据和算法优化方向。

建议:对于未来的研究,可以尝试将约瑟夫问题推广到更多变种,如双向报数、不同方向报数等,以及探索其在实际问题中的应用,如网络协议设计、资源分配等。

约瑟夫环设计实验报告

约瑟夫环设计实验报告

一、实验目的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)。

课程实验报告题目:2016.4.6学生姓名:黄玲学生学号:201408070105专业班级:智能1401指导老师:骆嘉伟完成日期:2016.4.6一.需求分析1.本实验基本要求是用数组来实现线性表,再基于线性表的基本操作(插入、删除、修改等)来实现约瑟夫问题2.由键盘输入总人数n和出列报数m3.在DOS界面上显示依次出圈的人的编号和最后一个留下的人,在当前文件夹里生成一个文本文件,里面是相同的输出。

4.测试数据:输入:10,3输出:3 6 9 2 7 1 8 5 10 4//DOS3 6 9 2 7 1 8 5 10 4//TXT二.概要设计§抽象数据类型为实现上述程序的逻辑功能,应以整数存储用户的输入用线性表实现,线性表定义如下:ADT LISt数据对象:整数基本操作:AList(100);//构建一个最大人数为100的顺序表(数组)来存储人Next();//指向下一个人moveStart();//回到第一个人继续数数Length();//查看圈里还剩多少人currPos();//查看当前数到人的编号getValue();//查看当前编号的人是否还在圈内§程序的流程以书上的代码案例为参考,编写线性表的ADT在继承线性表的基础上编写顺序表(数组)的类文件编写主函数,创建类的对象,完成程序三.详细设计§物理数据类型将大小为n的数组赋好值,其值为他本身的编号,即数组下标。

§程序思路的具体步骤实现设一个标志点,在数组中移动,同时报数,当报到m时,当前人的值变为0,出圈,然后继续移动,重新数。

当数到值为0的人时自动跳过(已出圈),当数输入please input n and m://提示等待输入等待输入输出x x x x x//DOS界面上一列数字x x x x x//TXT上一列数字五.测试结果输入8 5 输出 5 2 8 7 1 4 6 3输入12 7 输出7 2 10 6 4 3 5 9 1 8 11 12六.实验心得通过实验,对c++类的使用熟悉了一遍,同时对线性表这一数据结构有了更深的理解。

同时,了解了一个问题要从多个方向求解。

譬如,这个约瑟夫环问题,实验的基本要求是用线性表解决,然而也可以用链表解决。

甚至一个公式。

七.附录●线性表实现◎List.h#ifndef List_H#define List_Hclass List{private:void operator = (const List&) {}List(const List&){}public:List(){}virtual ~List(){}virtual void change(int num) = 0;virtual void moveToStart() = 0;virtual void moveToEnd() = 0;virtual void prev() = 0;virtual void next() = 0;virtual int length() const=0;virtual int currPos() const=0;virtual void moveToPos(int pos) = 0;};#endif◎AList.h#ifndef ALIST_H#define ALIST_H#include <assert.h>#include "List.h"class Alist : public List{private:int maxSize;int listSize;int curr;int *listArray;public:Alist(int size=100){maxSize=size;listSize=0;curr=1;listArray=new int[maxSize];}~Alist(){delete [] listArray;}void clear(){delete [] listArray;listSize=0;curr=0;listArray=new int[maxSize];}void insert(const int it){assert(listSize<maxSize);for(int i=listSize;i>curr;i--)listArray[i]=listArray[i-1];listArray[curr]=it;listSize++;}void append(const int it){assert(listSize<maxSize);listArray[listSize++]=it;}int remove(){assert((curr>=0)&&(curr<listSize));int it=listArray[curr];for(int i=curr;i<listSize-1;i++)listArray[i]=listArray[i+1];listSize--;return it;}void change(int num){listArray[curr]=num;}void moveToStart(){curr=0;}void moveToEnd(){curr=listSize;}void prev(){if(curr!=0) curr--;}void next(){if(curr<listSize) curr++;}int length()const{return listSize;}int currPos()const{return curr;}void moveToPos(int pos){assert((pos>=0)&&(pos<=listSize));curr=pos;}const int getValue()const{assert((curr>=0)&&(curr<listSize));return listArray[curr];}};#endif◎main.cpp#include "AList.h"#include <iostream>#include<fstream>using namespace std;int main(){int n,m,turn=1;ofstream fout("joseph.txt",ios::out);cout<<"please input n and m:\n";cin>>n>>m;int remain=n;Alist joseph(n);for(int i=0;i<n;i++)joseph.append(i+1);joseph.moveToStart();while(remain>=1){while(joseph.getValue()==0){if(joseph.currPos()!=n-1)joseph.next(); else joseph.moveToStart();}while(turn!=m){if(joseph.currPos()!=n-1)joseph.next();else joseph.moveToStart();if(joseph.getValue()!=0)turn++;}turn=1;remain--;cout<<joseph.getValue()<<"";fout<<joseph.getValue()<<"";joseph.change(0);}return 0;}●循环链表实现约瑟夫环问题代码:#include<iostream.h>#include<stdio.h>#include<fstream>using namespace std;struct LNode{int data;LNode *next;};//n为总人数,m为出列者喊到的数void joseph(int n, int m){ofstream fout("joseph.txt",ios::out);if( n<=0 || m<=0){throw "Invalid argument(s)";}//建立循环链表LNode *p = new LNode;p->data = 1;p->next = p;LNode *curr = p;for(int i=2;i<=n;i++){LNode *q = new LNode;q->data = i;p->next = q;q->next = curr;p=p->next;}//把当前指针移动到第一个报数的人LNode *pre;int m1=m;while(n--){while(--m1){pre = curr;curr = curr->next;}m1 = m;cout<<curr->data<<"";fout<<curr->data<<"";pre->next = curr->next;delete curr;curr = pre->next;}}int main(){int n,m;cout<<"please input the number of people n and the m:";cin>>n>>m;joseph(n,m);return 0;}。

相关文档
最新文档