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

合集下载

约瑟夫环实验报告

约瑟夫环实验报告

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

这个游戏的规则是:有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,但淘汰的间隔变得更长了,而且整体的淘汰顺序也有了一定的变化。

通过对约瑟夫环实验的多次观察和记录,我们可以总结出一些结论。

首先,淘汰的顺序呈现出周期性,并在最后几轮回到了初始的编号。

其次,在不同的实验条件下,淘汰的规律可能会有所不同。

数据结构课程设计 约瑟夫环问题(报告+代码)

数据结构课程设计      约瑟夫环问题(报告+代码)

学院计算机与信息工程系数据结构课程设计设计题目:约瑟夫环问题专业班级学号姓名指导教师2010年12月20日约瑟夫环一.实验目的:本实验是设计一个可以解决约瑟夫环问题的程序。

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

二.实验环境:VC2008.三.试验步骤:1.问题分析和任务定义本实验要求设计一个程序解决约瑟夫环问题,且要利用单向循环链表存储结构模拟此过程。

这就要求我们必须用链表结构而不能用像数组等其它结构。

首先输入的数据必须是整型且是整数,同样输出的也必须是整型且整数;其次也要备好测试数据(包括合法的输入数据和非法形式输入的数据)以此来检查程序是否符合要求;最后2.数据类型和系统设计链表存储结构的定义:typedef struct Node{}SeqList链表的建立:SeqList * Creat(int num){}链表的输出:void OutQueue(SeqList * tail, int num, int code){}3.详细设计:#include <stdio.h>#include <stdlib.h>typedef struct Node{int num;int code;struct Node * next;}SeqList;SeqList * Creat(int);void OutQueue(SeqList *, int , int );int main(){int n,m,i;printf( " 姓名:徐正杰学号:090502201:\n");printf("Input The Number of People, Frist Code:");{int num = 0,code = 0;scanf("%d%d",&num, &code);{SeqList * tail = NULL;tail=Creat(num);OutQueue(tail, num, code);}}return 0;}SeqList * Creat(int num){getchar();SeqList * tail = NULL;tail=(SeqList *)malloc(sizeof(SeqList));{int i = 1, code = 0;printf("Input Num.%d Code:", i);scanf("%d", &code);tail->num = i;tail->code = code;tail->next = tail;{SeqList * p = NULL;for(i = 2; i <= num; ++i){p = (SeqList *)malloc(sizeof(SeqList));if(p){printf("Input Num.%d Code:", i);scanf("%d", &code);p->num = i;p->code = code;p->next = tail->next;tail->next = p;tail = p;}else{perror("Out of menroy!");getchar();exit(1);}}}}return(tail);}void OutQueue(SeqList * tail, int num, int code) {printf("Out of Queue:");{SeqList * p;while(tail - tail->next){code=(code-1)%num+1;{int i;for(i = 1; i < code; ++i){tail = tail->next;}}p = tail->next;printf("%d,", p->num);tail->next = p->next;code = p->code;free(p);p = NULL;--num;}}printf("%d.",tail->num);free(tail);tail = NULL;}4.调试分析在本次试验调试中很不顺利。

实验报告——约瑟夫环

实验报告——约瑟夫环

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:约瑟夫环姓名:张光栋院系:计算机学院专业:网络工程年级: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.第一次写时,没有区分出只剩下的一个的情况,导致最终输出出现错误。

约瑟夫环问题实验报告

约瑟夫环问题实验报告

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

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

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

数据结构实验报告题目:约瑟夫环姓名:学号:专业班级:指导教师:课题工作时间:一.需求分析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()是最主要的函数,分别执行两种算法,并在执行的同时按照出列顺序输出元素信息(编号,密码),并在结尾输出两种算法执行所用的时间长短。

约瑟夫环问题课程设计报告

约瑟夫环问题课程设计报告

数据结构课程设计报告设计课题:约瑟夫问题院系:计算机科学与技术学院专业班级:计算机网络技术1102 班学生姓名:张利学号: 1 1 0 8 0 4 0 2 1 1指导教师:王昱哲目录1. 需求剖析 . (3)1.1 问题描绘 (3)1.2功能剖析 (4)2. 纲要设计 . (5)3. 详尽设计 . (6)4. 调试与操作说明 ........... 1 错误 ! 不决义书签。

总结 . (16)一.需求剖析1.1 问题描绘瑟夫描绘的是:号1,2,⋯, n 的 n(n>0)个人按方向坐一圈,每一个人拥有一正整数密。

开始一个正整数作数上限m,从第一个人开始方向自 1 起序数,到 m停止数, m的人出圈,将他的密作新的 m,从他在方向上的下一个人起从头从 1数。

这样下去,直到所有人都出圈止。

令n 最大 100。

要求一个程序模此程,求出出圈的号序列。

以下剖析:这是第一个人,他的密码是“ 1”,个他输一个 m 值,假如 m=3,则从他开始向下走3个213这就是第二步的地点,这时他的密码作为新的m 值,即 m=4,同时获得的第一个密码为4;4 号出去处下走4,到9 这儿;(这这一步完了剩余的为:041,2,3,5,6 ,, 7,8,9,0,)95867这就是第三步的地点,这时他的密码作为新的m值,即m=9 ,同时获得的第二个密码为9;9 号出去处下走9,到 0 这儿;持续走就行了(这儿节余的就是: 1 , 2, 3, 5,6,7,8,0)图 1 约瑟夫环问图解第三步:约瑟夫环原理演示图第二次, 1 号出列1234567 3172484第四步:第三次,第一步:给第一个人第二部:第一次停下的地点,此赋初始密码为: 20则4 号出列时 6 号出列,并将他的值作为新从它开始向下走20的 m 值,即:新的 m=8;从 7次,到 6 号地点好开始持续向下走8 次,到 1 号最后排序后的密码序列:的地点(本图只演示前两步)8324174 6147235图 2约瑟夫环原理演示图1.2 功能剖析约瑟夫环问题是一个古老的数学识题,本次课题要求用程序语言的方式解决数学识题。

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

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

数据结构约瑟夫环实习报告一、实习题目约瑟夫环(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值}}```五、实验结果与分析通过以上程序设计,我们可以得到约瑟夫环的出列顺序。

实验报告:约瑟夫环

实验报告:约瑟夫环

实验报告:约瑟夫环一.需求分析1.本实验中,要求模拟N个持有密码的人在一种出序规则下的出序情况,每人有一个密码,并且N人在顺时针方向编号为1,2……N,在给予一个初始密码时要求将出序的人的序号打印出以摸拟该过程。

2.程序以计算机提示的方式出现,在显示提示信息后由用户从键盘上输入相应的信息。

3.测试数据M初值为20,N=7,7人的密码依次为:3,1,7,2,4,8,4,输入后正确的输出顺序为6,1,4,7,2,3,5。

二.概要设计为实现上述模拟功能,应以循环链表表示被编号的人。

为此,仅需要一个数据类型:循环链表。

1.循环链表的抽象数据类型定义为:ADT linkpeople{数据对象:D={a i|a i∈elepeople, i=1,2,3……,n}数据关系:R1={<a i-1,a i>|a i-1,a i∈D,i=1,2,……n}基本操作:creatcircle(&L)初始条件:L不存在。

操作结果:构造一个环形链表。

Workcircle(&L)初始条件:环形链表已存在。

操作结果:按所给规则处理链表,并释放退出循环的结点。

}ADT Linkpeople2.本程序包含三个模块:(1)主程序模块:int main(){读入初始值;构造链表;处理链表;}(2)创立链表模块——创立环形链表。

(3)处理链表模块——处理链表。

各模块之间的调用关系如下:创立模块处理模块三.详细设计1.元素结点类型typedef struct people{int number;int code;struct people *next;}elepeople,*linkpeople;2.模块设计linkpeople creatcircle(linkpeople p,int n){int i;linkpeople k,q,r;printf("please enter code \n");q=p;k=p;for(i=1;i<=n;i++){ if(i==n){k->next=q;k->number=n;scanf("%d",&k->code);}//处理最末的输入数据else{ scanf("%d",&k->code);k->number=i;r=(linkpeople)malloc(sizeof(elepeople));k->next=r;k=k->next;} //依此处理输入数据}return k;//返回最后结点指针}//creatcirclevoid workcircle(linkpeople q,int m){int c;linkpeople p,r;p=q;printf("the sequence of outpeople\n");while(p!=p->next){for(c=1;c<=m-1;c++)p=p->next;//找到处理结点前一个指针printf("%d ",p->next->number);m=p->next->code;r=p->next;p->next=p->next->next;free(r);}printf("%d ",p->number);free(p);//处理最后结点}//workcircle3.主函数int main(){int m;int n;linkpeople s;linkpeople p;printf("please enter the first code and sum of people\n");scanf("%d %d",&m,&n);p=(linkpeople)malloc(sizeof(elepeople));s=creatcircle(p,n);workcircle(s,m);return 0;}//main4.函数调用关系creatcircle workcircle四.调试分析1.在creatcircle的操作中,对其参数的传值问题未认真推敲,导致运行有误,以后应该注意。

约瑟夫环课程设计报告

约瑟夫环课程设计报告

课程设计报告课程设计名称:数据结构课程设计课程设计题目:约瑟夫环院(系):专业:班级:学号:姓名:指导教师:目录1 课程设计介绍 (1)1.1课程设计内容 (1)1.2课程设计要求 (1)2 课程设计原理 (2)2.1课设题目粗略分析 (2)2.2原理图介绍 (2)2.2.1 功能模块图(如图2.1) (2)2.2.2 流程图分析 (3)3 数据结构分析 (5)3.1存储结构 (5)3.2算法描述 (5)4 调试与分析 (6)4.1调试过程 (6)4.2程序执行过程 (6)参考文献 (8)附录(关键部分程序清单) (9)1 课程设计介绍1.1 课程设计内容编号为1,2,……,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。

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

使用单循环链表作为存储结构分析:由题意可以将每个人看做链表上的一个节点,每个人持有的密码即为每个节点所存储的数据;相邻的人之间存在连结关系,即链表的两个相邻节点之间由指针来进行关联;最后一个人和第一个人也存在连结关系,即链表的末尾节点和头结点相连构成了单循环链表存储结构。

执行报数过程可以看做一个单独指针依次指向每一个节点,有人出列即删除掉链表中相应的节点。

1.2 课程设计要求1.参考相应的资料,独立完成课程设计任务。

2.交规范课程设计报告和软件代码。

2课程设计原理2.1 课设题目粗略分析根据课设题目要求,程序应该分为两大部分:1、单循环链表储存结构的建立:建立所需的单循环链表数据存储结构,对每个节点输入所需的密码、序号数据并通过指针连接成单循环链表。

2、实现约瑟夫环数据出列顺序的算法:依照题目要求按照报数上限对节点进行查找和删除操作,按顺序输出出列的节点序号,依照每次出列的节点存储的密码修改报数上限循环操作直到全部节点出列完毕程序运行结束。

(完整word版)约瑟夫环课程设计实验报告

(完整word版)约瑟夫环课程设计实验报告

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目: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. 概述约瑟夫环问题是一个经典的数学问题,该问题是以约瑟夫·弗拉维奥(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无关。

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

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

课程设计报告一、需求分析1、本演示程序中,利用单向循环链表存储结构模拟约瑟夫问题的进行。

程序运行后,首先要求用户指定初始报数上限值,然后读取个人的密码。

可设n≤30。

此题所用的循环链表中不需要“头结点”,因此在程序设计中应注意空表和非空表的界限。

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

3、程序执行的命令包括:1)构造约瑟夫环;2)执行约瑟夫环,并输出出列人的序号以及相应的密码;3)结束。

4、测试数据1)m的初始值为20;2)n=7,7个人的密码依次为:3、1、7、2、4、8、4。

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

二、概要设计为实现上述程序功能,应以单向循环链表表示约瑟夫环。

为此,需要两个抽象数据类型:单向循环链表和约瑟夫环。

1)、单向循环链表的抽象数据类型定义为:ADT List{数据对象:D={ai|ai∈Elemset,i=1,2,…,n,n≥0}数据关系:R1={<a(i-1),ai>|a(i-1),ai∈D,i=2,…n}基本操作:InitList(&L)操作结果:构造一个空的链表L。

DestroyList(&L)初始条件:线性表L已存在。

操作结果:销毁线性表L。

ListLength(L)初始条件:线性表L已存在。

操作结果:返回L中数据元素个数。

GetElem(L,i,&e)初始条件:线性表L已存在,1≤i≤ListLength(L)。

操作结果:用e返回L中第i个数据元素的值。

ListInsert(&L,I,e)初始条件:线性表L已存在,1≤i≤ListLength(L)+1。

操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1。

ListDelete(&L,i,&e)初始条件:线性表L已存在且非空,1≤i≤ListLength(L)。

约瑟夫环实验报告

约瑟夫环实验报告

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

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

约瑟夫环问题 实验报告完整版
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;

约瑟夫环实习报告

约瑟夫环实习报告

实习报告:约瑟夫环实验一、实习背景约瑟夫环问题是一个经典的计算机科学和数学问题,起源于古罗马时期的历史故事。

问题描述了n个人围成一个圆圈,从第一个人开始报数,每数到m个人就将其删除,然后从下一个人重新开始报数,直到圈中只剩下一个人。

本实习报告旨在通过实现约瑟夫环算法,深入理解其原理和应用,并分析不同算法实现的时间和空间复杂度。

二、实习内容1. 算法实现本次实习实现了两种约瑟夫环算法的实现:迭代法和递归法。

迭代法使用循环结构模拟圆圈的过程,每轮删除指定数量的节点,直到只剩下一个节点。

递归法则利用递归函数模拟这个过程,每次递归调用删除指定数量的节点,直到只剩下一个节点。

2. 算法分析在算法分析方面,我们主要从时间复杂度和空间复杂度两个方面进行考虑。

对于迭代法,时间复杂度主要取决于删除节点的次数,每次删除操作的时间复杂度为O(1),因此总的时间复杂度为O(n)。

空间复杂度主要取决于程序的存储空间,由于使用了循环结构,空间复杂度为O(n)。

对于递归法,每次递归调用都会创建一个新的栈帧,因此空间复杂度主要取决于递归深度。

在最坏情况下,递归深度为n-1,因此空间复杂度为O(n)。

时间复杂度同样为O(n),因为每次递归调用都需要进行删除操作。

3. 实验结果我们使用Python语言实现了约瑟夫环算法,并使用Python的time模块测量了不同算法实现的时间。

实验结果显示,在n较小的情况下,迭代法和递归法的运行时间相差不大。

但随着n的增大,迭代法的运行时间逐渐优于递归法。

这是因为递归法在每次递归调用时都会创建新的栈帧,随着递归深度的增加,栈帧的创建和销毁会占用较多的时间。

三、实习心得通过本次实习,我对约瑟夫环问题有了更深入的理解。

在实现算法的过程中,我学会了如何使用循环结构和递归函数模拟圆圈的过程。

在分析算法的过程中,我学会了如何计算时间复杂度和空间复杂度,并能够根据实际情况选择合适的算法。

同时,我也认识到算法优化的重要性。

约瑟夫环课程设计报告

约瑟夫环课程设计报告

C++ 课程设计报告课 题: 约瑟夫环 专业班级: 学 号: 姓 名: 指导教师:目 录评阅意见:评定成绩:指导老师签名:年 月 日1 课程设计的目的和意义 (2)2 需求分析 (3)3 系统(项目)设计 (4)(包括总体设计和详细设计) (4)一、设计思路及方案 (4)二、模块的设计及介绍 (4)(2)创建单循环链表函数流程图 (6)(3)删除结点函数(出队函数)程序流程图 (7)4 系统实现 (8)5 系统调试 (11)参考文献 (15)附录源程序 (16)1 课程设计的目的和意义数据结构是研究数据元素之间的逻辑关系的一门课程,以及数据元素及其关系在计算机中的存储表示和对这些数据所施加的运算。

该课程设计的目的是通过课程设计的综合训练,培养分析和编程等实际动手能力,系统掌握数据结构这门课程的主要内容。

本次课程设计的内容是用单循环链表模拟约瑟夫环游戏,循环链表是一种首尾相接链表,其特点是无须增加存储容量,仅对表的链接方式稍作改变,使表处理更加灵活,约瑟夫环问题就是用单循环链表处理的一个实际应用。

通过这个设计实例,了解单链表和单循环链表的相同与不同之处,进一步加深对链表结构类型及链表操作的理解。

通过该课程设计,能运用所学知识,能上机解决一些实际问题,了解并初步掌握设计、实现较大程序的完整过程,包括系统分析、编码设计、系统集成、以及调试分析,熟练掌握数据结构的选择、设计、实现以及操作方法,为进一步的应用开发打好基础。

2 需求分析该程序所做的工作是约瑟夫环游戏,有以下内容和要求:1.本程序设计中,从键盘输入约瑟夫环游戏的总人数n和初始的报数上限m,然后给每个人输入所持有的密码key。

用单循环链表模拟约瑟夫环,从队头开始从1报数,报到m的人出列,再把此人的密码赋给m,继续下一轮的报数,直到所有的人出列。

2.演示程序以用户和计算机对话方式进行,根据提示信息由用户从键盘输入数据,以“回车符“为结束标志,运行后输出的结果是约瑟夫环的相关信息和经过报数后出队的人的序列号及相关信息。

约瑟夫环实验报告

约瑟夫环实验报告
#define max 1000//宏定义
class JosephCircle//定义JosephCircle类
{
public://定义成员函数
void input();
bool check();
void ruivate://定义成员变量
int totalNumber;
五、
1.使用了宏定义,在类初始化时定义了数组a[1000],造成内存大量浪费,降低了程序的效率;
2.类的封装不好,程序的可读性比较差;
3.注释描述不清。
六、
通过这次实验,对类和约瑟夫环的数组算法有了深刻的理解,对相关内容有了更熟练的掌握。由于对编程还不是很熟悉,实验过程中出现了很多错误,但调试过后大部分解决了。查阅资料,请教同学,分析问题,解决问题,提高了自己的动手能力。
int beginNumber;
int outNumber;
int a[max];
};
void JosephCircle::input()//输入人数、开始位置编号和第几个出列
{
cout<<"请输入人数: ";
cin>>totalNumber;
cout<<"请输入开始位置编号: ";
cin>>beginNumber;
return false;
}
return true;
}
void JosephCircle::run()//寻找合适的值
{
for(int j = 0; j < totalNumber; j++)//为数组赋值
{
a[j] = j + 1;

约瑟夫环实验报告

约瑟夫环实验报告

程序设计课程设计报告项目名称:约瑟夫环学生姓名:学号:班级:计科1111班指导老师:日期:2013年1月3号1、项目描述约瑟夫问题主要是n个人围坐成一个圈,然后分别给每个参与者编一个号,再定义一个循环数,由玩家自定义起始报数者,当游戏开始时,报数为循环数的人被踢出,其他人继续。

此设计就是通过一位数组、一维结构体数组与循环链表来实现这些功能的。

2、项目的需求分析在软件工程中,需求分析指的是在建立一个新的或改变一个现存的系统或产品时,确定新系统的目的、范围、定义和功能时所要做的所有工作。

需求分析是软件工程中的一个关键过程。

在这个过程中,系统分析员和软件工程师确定顾客的需要。

只有在确定了这些需要后他们才能够分析和寻求新系统的解决方法。

需求按层次分为用户需求和系统需求:用户需求是用自然语言加图的形式给出的、关于系统需要提供哪些服务以及系统操作受到哪些约束的声明;系统需求详细地给出系统将要提供的服务以及系统所受到的约束,系统需求文档有时也称为功能描述,应该是精确的,它可能成为系统买方和软件开发者之间合同的重要内容。

软件系统需求常常分为功能需求和非功能需求:功能需求包括对系统应该提供的服务、如何对特殊输入做出反应,以及系统在特定条件下的行为的描述,在某些情况下,功能需求可能还需声明系统不应该做什么;非功能需求是对系统提供的服务或功能的约束,包括时间约束、开发过程的约束和所受到的标准的约束,非功能需求经常适用于整个系统而不是个别的系统功能或服务,例如性能,可靠性,安全性和可用性等。

非功能需求通常会比个别的功能需求更加关键,它会影响整个系统的体系结构,而不是个别的组件。

例如,为了保证系统的性能需求,就必须合理组织系统使得组件之间的通信量达到最小。

图 1 需求获取和分析的产品2.1、界面需求Microsoft Visual C++ 6.0软件里面实现代码操作,Microsoft Office Word 20032.2、输入输出要求才用C++中的输入输出函数,即cin与cout,而在C中用printf即可。

约瑟夫环设计实验报告

约瑟夫环设计实验报告

一、实验目的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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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; //顺序int code; //密码LinkNode *next;};建立一个类LinkList ,包含的函数:LinkList(); //构造函数void Creat(const int ); //创建循环链表int Delete(LinkNode* ); //删除报到数的结点int Joseph(int ); // 约瑟夫环私有成员是LinkNode* head; //指向第一个结点的指针LinkNode* elem; // 同上int len; //长度我定义了一个elem指针是为了约瑟夫环里运行方便,elem只在约瑟夫环这个函数里用到,其他函数没有特别大的用处。

构造函数与书上的没什么大差别,创建循环链表时,要考虑几个问题,一个是题目要求是不带头结点,所以head指针直接指向了第一个结点,我在创建链表时把第一个结点初始化data为1,表明这个结点是第一个结点。

具体如下:void LinkList::Creat(const int number) //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;}在构建约瑟夫环的执行函数时,我首先考虑了递归调用的函数,原本的这个程序的所有的都定为elemtype类型的,虽然编译没出错,但是在连接时发生了错误,在老师的指导下改成了具体的int型。

int LinkList::Joseph(int m){if(len>1){LinkNode *q;if(m==1) //在初始报数为1的情况下{q=elem;int a=q->code; //将选中的结点的密码记录在a中elem=elem->next;cout<<Delete(q)<<endl; //Delete函数是为了将已经报过数的人删除Joseph(a); //用已经删除的结点的存的密码作为下一次循环的报数值}else //一般情况下{for(int i=1;i<m;i++)elem=elem->next; //找到需要出列的结点q=elem;elem=elem->next; //此处的elem指针指向要删除的结点的下一个结点,下次递归调用时从这里开始向下循环报数int a=q->code;cout<<Delete(q)<<endl;Joseph(a);}}else //在只有一个结点的情况下cout<<head->data;}最后还有一个Delete函数,在删除结点的时候要考虑几个特殊情况,头尾结点。

删除第一个结点时,需要将head指针下移,尾结点的next也要指向第二个结点;删除尾结点时,要将尾结点前的结点与第一个结点相连。

在设计这个函数时,我只考虑了当len大于1的情况,在只剩下一个结点时,不必要删除,直接输出data的值即可(在约瑟夫函数中有写)。

具体函数如下:int LinkList::Delete(LinkNode *a){if(len>1) //只考虑长度大于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--; //用len记录删除后的循环链表的长度return out;}else{LinkNode* q=head;int out=a->data;while(q->next!=a){q=q->next;}if(a->next=head) .//删除的是尾结点时(不知道为什么我写程序里总是编译出现错误){q->next=head; //重新链接delete a;len--;return out;}else{q->next=a->next;delete a;len--;return out;}}}}5、测试结果:6 程序清单:#include <iostream.h>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);}}elsecout<<head->data;}int main(){int num,code;cout<<"请输入人数: ";cin>>num;LinkList L;L.Creat(num);cout<<"请输入第一个上限数: ";cin>>code;cout<<"出列顺序:"<<endl;L.Joseph(code);return 0;}4、小结一、这次课程设计的心得体会通过实践我的收获如下:一开始接触数据结构课程设计真的挺难的,好多都不会,不是逻辑方面的问题,而是不具备动手能力,脑子里总有一团火,比如对于这个题目,一开始有很多的想法,想到了从逻辑上怎么实现他,要编写哪些程序,但是一到需要编写了就开始为难了,可以说是几乎不知道从哪里入手,参考了书本里的程序,仿照他的结构一步一步做下来,现在对于单链表的各种操作已经算是比较熟练了,让我知道光有理论知识还远远不够,需要多动手,写的多了自然就能手到擒来。

相关文档
最新文档