约瑟夫问题数据结构实验报告要点

约瑟夫环的知识点总结约瑟夫环这个问题不仅在古代受到了广泛的关注，而且在现代数学中也有着重要的地位。

它涉及到了排列、递推、循环和递归等多个数学概念，并且有着一些有趣的数学特性。

因此，学习约瑟夫环不仅能够增加我们对于数学问题的理解，而且也可以提高我们的数学思维能力。

接下来，我们将从几个方面对约瑟夫环进行深入的讨论。

1. 约瑟夫环的历史约瑟夫环最早出现在约瑟夫斯的《犹太古记》中，他描述了犹太人在与罗马军队的战斗中围攻马萨达城的情景。

根据《犹太古记》的记载，当罗马军队攻陷了马萨达城后，大约960名男子决定宁死不从。

于是，他们站成一个圈，每隔两个人就有一个杀掉，直到最后只剩下一个人。

而这个幸存者恰恰就是约瑟夫斯本人。

因此，这个问题就得名为约瑟夫环。

除了这个故事之外，约瑟夫环在古代数学文献中也有着多次的提及。

例如，中国古代数学家秦九韶在其著作《数书九章》中也提到了这个问题。

他利用递推的方法解出了约瑟夫环的一般解，并推广到了更一般的情况。

自古代以来，约瑟夫环一直受到数学家们的关注，他们提出了很多不同的方法来解决这个问题。

而到了现代，约瑟夫环在计算机科学和密码学中也有着广泛的应用。

因此，约瑟夫环问题可以说是一个古老而又具有重要意义的数学问题。

2. 约瑟夫环的一般解在数学中，我们可以用递推的方法对约瑟夫环进行求解。

假设有N个人站成一圈，编号从0到N-1，而每隔M个人就有一个人出列。

那么一个简单直接的方法就是用递归来求解。

具体来说，我们可以定义一个递归函数f(n, m)，表示N个人中最后存活下来的那个人的编号。

那么这个函数的递归关系可以如下定义：f(n, m) = (f(n-1, m) + m) % n其中f(1, m) = 0，表示只有一个人时的情况。

通过递归的方法，我们可以得到约瑟夫环的一般解。

而根据这个递归关系，我们还可以得到一些有趣的数学性质。

例如，我们可以求解约瑟夫环在给定N和M的情况下的解，而不需要实际模拟整个过程。

1 线性表及其应用问题：约瑟夫环问题描述：编号为1，2，…，n的n个人按顺时针方向围坐一圈。

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

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

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

基本要求：利用单向循环链表存储结构模拟此过程。

2 栈和队列及其应用题目：魔王语言解释问题描述：有一个魔王总是使用自己的一种非常精练而抽象的语言讲话，没有人能听的懂，但他的语言是可以逐步解释成人能听懂的语言，因为他的语言是由以下两种形式的规则由人得语言逐步抽象上去的：（1）α→β1β2…βm（2）(θδ1δ2…δn)→θδnθδn-1…θδ1θ在这两种形式中，从左到有均表示解释。

试写一个魔王语言的解释系统，把他的话解释成人能听的懂的话。

基本要求：用下述两条具体规则和上述规则形式（2）实现。

设大写字母表示魔王语言的词汇；小写字母表示人的语言词汇；希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

（1）B→tAdA（2）A→sae3 串及其应用题目：文学研究助手问题描述：存在一篇英文文章(以串表示)，以及若干关键字。

编写程序统计关键字的出现次数。

基本要求：改进KMP算法以适应多关键字匹配。

4 数组和广义表题目：数组转置问题描述：存在稀疏矩阵A，编写程序将A转置为B。

基本要求：用三元组表示稀疏矩阵，应用算法5.2完成转置。

5 树、图及其应用题目：Huffman编/译码器问题描述：使用Huffman编码进行通信可以节省通信成本。

对于双工系统而言，要求在发送端和接受端均有编码器和译码器。

试为该系统设计一个编/译码器。

基本要求：至少具有功能（1）初始化（2）编码（3）译码（4）打印代码。

6 存储管理、查找和排序题目：内部排序算法比较问题描述：通过随机数据比较各算法的关键字比较次数与移动次数。

实验一线性表操作一、实验目的1熟悉并掌握线性表的逻辑结构、物理结构。

2熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。

3熟悉VC++程序的基本结构，掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。

4熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。

二、实验要求1实验之前认真准备，编写好源程序。

2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题:1对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。

加强、提高题：2、编写一个求解Josephus问题的函数。

用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。

然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为输入数据，检查你的程序的正确性和健壮性。

最后分析所完成算法的时间复杂度。

定义JosephusCircle类，其中含完成初始化、报数出圈成员函数、输出显示等方法。

（可以选做其中之一）加强题：（1）采用数组作为求解过程中使用的数据结构。

提高题：（2）采用循环链表作为求解过程中使用的数据结构。

运行时允许指定任意n、s、m数值，直至输入n = 0退出程序。

实验二栈、队列、递归应用一、实验目的1熟悉栈、队列这种特殊线性结构的特性2熟练掌握栈、队列在顺序存储结构和链表存储结构下的基本操作。

二、实验要求1实验之前认真准备，编写好源程序。

2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题（必做）：1分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。

2、假设以带头结点的循环链表表示队列，并且只设一个指针指向对尾结点，不设头指针，试设计相应的置队空、入队和出队的程序。

加强题：3设线性表A中有n个字符，试设计程序判断字符串是否中心对称，例如xyzyx和xyzzyx都是中心对称的字符串。

《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现，其中以熟悉各种链表的操作为重点。

2、巩固高级语言程序设计方法与技术，会用线性链表解决简单的实际问题。

二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。

2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范，及时完成实验报告。

四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（成员函数）的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释，说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释，说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针，返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）说明：以后每次实验报告均按此格式书写。

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

约瑟夫环问题问题描述：有n个⼈，编号分别从0到n-1排列，这n个⼈围成⼀圈，现在从编号为0的⼈开始报数，当报到数字m的⼈，离开圈⼦，然后接着下⼀个⼈从0开始报数，依次类推，问最后只剩下⼀个⼈时，编号是多少？分析：这就是著名的约瑟夫环问题，关于来历不再说明，这⾥直接分析解法。

解法⼀：蛮⼒法。

我曾将在⼤⼀学c语⾔的时候，⽤蛮⼒法实现过，就是采⽤标记变量的⽅法即可。

解法⼀：循环链表法。

从问题的本质⼊⼿，既然是围成⼀个圈，并且要删除节点，显然符合循环链表的数据结构，因此可以采⽤循环链表实现。

解法三：递推法。

这是⼀种创新的解法，采⽤数学建模的⽅法去做。

具体如下：⾸先定义⼀个关于n和m的⽅程f(n,m)，表⽰每次在n个编号0，1，...，n-1中每次删除的报数为m后剩下的数字，在这n个数字中，第⼀个被删除的数字是(m-1)%n，为了简单，把(m-1)%n记作k，那么删除k之后剩下的数字为0，1，2，...，k-1，k+1，...，n-1并且下⼀次删除的数字从k+1开始计数，这就相当于剩下的序列中k+1排在最前⾯，进⽽形成k+1,..,n-1,0,1,2,...,k-1这样的序列，这个序列最后剩下的数字应该和原序列相同，由于我们改变了次序，不能简单的记作f(n-1,m),我们可以记作g(n-1,m),那么就会有f(n,m)=g(n-1,m).下⼀步，我们把这n-2个数字的序列k+1,..,n-1,0,1,2,...,k-1做⼀个映射，映射的结果是形成⼀个从0到n-2的序列。

k+1对0，k+2对1，......，n-1对n-k-2，0对n-k-1，1对n-k，....，k-1对n-2这样我们可以把这个映射定义为p,则p(x)=(x-k-1)%n,它表⽰如果映射前的数字是x，映射后为(x-k-1)%n,从⽽这个映射的反映射问为p-1(x)=(x+k+1)%n由于映射之后的序列和原始序列具有相同的形式，都是从0开始的序列，所以可以⽤函数f来表⽰，即为f(n-1,m)，根据映射规则有：g(n-1,m)=p-1[f(n-n,m)]=[f(n-1,m)+k+1]%n,最后把之前的k=(m-1)%n带⼊式⼦就会有f(n,m)=g(n-1,m)=[f(n-1,m)+m]%n.这样我们就可以得出⼀个递推公式，当n=1时，f(n,m)=0;当n>1时，f(n,m)=[f(n-1,m)+m]%n;有了这个公式，问题就变得多了。

约瑟夫环知识点总结1. 约瑟夫环的数学模型约瑟夫环可以用数学的方式进行建模和解决。

通常情况下，我们把约瑟夫环的问题理解为一个数学公式的求解。

假设n个士兵分别编号为1、2、3、...、n，m为出列的间隔数。

首先，我们可以得到第一个出列的士兵编号为(m-1)%n+1，例如当n=7，m=3时，第一个出列的士兵为(3-1)%7+1=3。

之后，每次出列后的编号变换规律为：下一个出列士兵的编号为前一个出列士兵编号加上m在n取模后的结果，并且再对n取模，即f(i)=f(i-1)+m)%n。

以上公式是解决约瑟夫环问题的核心，因为根据这个公式可以有效地计算出每一轮出列的士兵的编号。

然后我们只需要循环迭代这个公式，直到最后只有一个士兵为止，这个士兵的编号就是最后的结果。

2. 约瑟夫环的递归解法除了上述的数学模型，还可以使用递归的方法来解决约瑟夫环的问题。

递归是一种非常高效的解决问题的方法，适用于很多数学问题，包括约瑟夫环的计算。

递归方法的求解思路是：先假设已知了n-1个士兵的约瑟夫环问题的解f(n-1, m)，那么我们要求的n个士兵的约瑟夫环的解f(n, m)可以通过以下方式推导得到。

首先，第一个出列的士兵编号为(m-1)%n+1，之后剩下的n-1个士兵重新排列成一个圆圈，编号重新从1到n-1。

将这n-1个士兵的解f(n-1, m)映射到n个士兵的解f(n, m)上，此时，再回到上述的数学模型进行计算，找到最终的结果。

递归的思路虽然清晰，但是在实际求解的过程中，由于递归的不断嵌套，计算量会非常庞大，不适合解决大规模的约瑟夫环问题。

3. 约瑟夫环的迭代解法在解决实际问题的时候，我们更多地使用迭代的方法来求解约瑟夫环的问题。

迭代的思路是从最简单的情况开始，然后不断迭代得到更加复杂的情况的解。

对于约瑟夫环问题，迭代的思路是逐步得出每一轮出列的士兵的编号并记录下来，直到剩下最后一个士兵为止。

通常情况下，我们会使用一个数组或者链表来保存每一轮出列的士兵的编号，最后得出最后一个士兵的编号。

约瑟夫环心得(精品3篇)约瑟夫环心得篇3约瑟夫环问题是一个经典的数学问题，其历史可以追溯到古希腊时期。

这个问题涉及到循环数组、计数器和数学推理，对于了解算法和数据结构非常有用。

在这个问题中，我们考虑了一个循环数组，其中包含n个人，每个人的编号从1到n。

我们想要找到一种方法，使得经过m次移位后，所有的人都被消除。

为了解决这个问题，我们可以使用递归或循环算法。

递归算法是一种基于函数调用的方法，它可以通过不断地将当前数组中的最大值移除来解决问题。

然而，这种方法在处理大量数据时可能会导致堆栈溢出。

因此，我们需要使用循环算法来避免这种情况。

循环算法的基本思想是使用计数器来跟踪当前要移除的人的编号。

我们可以通过循环遍历数组，每次移除计数器所指向的人来实现移除操作。

然而，这种方法可能导致数组不循环，从而导致问题无法解决。

因此，我们需要使用计数器和移除操作来构建一个循环数组。

解决约瑟夫环问题需要仔细考虑算法的效率和适用性。

在实际应用中，我们需要考虑问题的规模和数据类型，以确保算法能够有效地处理大量数据。

同时，我们需要理解算法的原理和实现细节，以便更好地理解和优化算法。

总之，约瑟夫环问题是一个有趣的数学问题，它可以帮助我们更好地理解循环数组、计数器和数学推理。

在解决这个问题时，我们需要仔细考虑算法的效率和适用性，并理解算法的原理和实现细节。

约瑟夫环心得篇4心得体会应由本人根据自身实际情况书写，以下仅供参考，请您根据自身实际情况撰写。

约瑟夫环问题是一个经典的数学问题，它涉及到循环队列和约瑟夫问题的应用。

这个问题在计算机科学、数学和经济学等领域都有广泛的应用。

在解决约瑟夫环问题时，我们需要考虑一些关键的算法和数据结构。

首先，我们需要使用循环队列来模拟约瑟夫环中的环。

其次，我们需要使用递归或循环来解决约瑟夫问题。

最后，我们需要使用一些优化技巧来提高算法的效率。

通过解决约瑟夫环问题，我学到了很多有用的算法和数据结构。

例如，我学会了如何使用循环队列来模拟约瑟夫环中的环，如何使用递归或循环来解决约瑟夫问题，以及如何使用一些优化技巧来提高算法的效率。

约瑟夫环无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。

我们注意到原问题仅仅是要求出最后的胜利者的序号，而不是要读者模拟整个过程。

因此如果要追求效率，就要打破常规，实施一点数学策略。

为了讨论方便，先把问题稍微改变一下，并不影响原意：问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。

求胜利者的编号。

我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k=m%n的人开始）:k k+1 k+2 ... n-2, n-1, 0, 1, 2, ... k-2并且从k开始报0。

现在我们把他们的编号做一下转换：k --> 0k+1 --> 1k+2 --> 2......k-2 --> n-2k-1 --> n-1变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x 是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x'=(x+k)%n如何知道(n-1)个人报数的问题的解？对，只要知道(n-2)个人的解就行了。

(n-2)个人的解呢？当然是先求(n-3)的情况---- 这显然就是一个倒推问题！好了，思路出来了，下面写递推公式：令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]递推公式f[1]=0;f[i]=(f[i-1]+m)%i; (i>1)有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。

因为实际生活中编号总是从1开始，我们输出f[n]+1由于是逐级递推，不需要保存每个f[i]，程序也是异常简单：#include <stdio.h>int main(){int n, m, i, s=0;printf ("N M = "); scanf("%d%d", &n, &m);for (i=2; i<=n; i++) s=(s+m)%i;printf ("The winner is %d\n", s+1);}这个算法的时间复杂度为O(n)，相对于模拟算法已经有了很大的提高。