数据结构约瑟夫环课程设计报告书
约瑟夫环问题 实验报告

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; } 测试用例:
数据结构课程设计 约瑟夫环问题(报告+代码)

学院计算机与信息工程系数据结构课程设计设计题目:约瑟夫环问题专业班级学号姓名指导教师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.第一次写时,没有区分出只剩下的一个的情况,导致最终输出出现错误。
约瑟夫环程序设计报告书

4:课程设计报告书附件《数据结构》课程设计报告环Joseph)约瑟夫(第七组别组组长成组员成绩教师指导计算机科学与技术系日11月6年2014.摘要约瑟夫环问题是典型的线性表的应用实例,其开发主要包括后台数据库的建立和维护以及前端应用程序的开发两个方面。
对于前者要求建立起数据一致性和完整性强、数据安全性好的库。
而对于后者则要求应用程序功能完备,易使用等特点。
经过分析,我们使用MICROSOFT公司的Microsoft Visual C++6.0开发工具,利用其提供的各种面向对象的开发工具,尤其是数据窗口这一能方便而简洁操作数据库的智能化对象,首先在短时间内建立系统原型,然后,对初始原型系统进行需求迭代,不断修正和改进,直到形成用户满意的可行系统。
关键词:单循环链表;c 语言;约瑟夫环;序言数据结构是研究数据元素之间的逻辑关系的一门课程,以及数据元素及其关系在计算机中的存储表示和对这些数据所施加的运算。
该课程设计的目的是通过课程设计的综合训练,培养分析和编程等实际动手能力,系统掌握数据结构这门课程的主要内容。
本次课程设计的内容是用单循环链表模拟约瑟夫环问题,循环链表是一种首尾相接链表,其特点是无须增加存储容量,仅对表的链接方式稍作改变,使表处理更加灵活,约瑟夫环问题就是用单循环链表处理的一个实际应用。
通过这个设计实例,了解单链表和单循环链表的相同与不同之处,进一步加深对链表结构类型及链表操作的理解。
通过该课程设计,能运用所学知识,能上机解决一些实际问题,了解并初步掌握设计、实现较大程序的完整过程,包括系统分析、编码设计、系统集成、以及调试分析,熟练掌握数据结构的选择、设计、实现以及操作方法,为进一步的应用开发打好基础。
章节安排1........................... 摘要、序言....一、问题描述1、课程设计目的.................. (4)2、课程设计任务.................. (4)二、设计过程1、设计思想(数据结构).................. . (4)2、设计表示(函数说明).................. . (5)3、详细设计(主要算法).................. . (6)4、用户手册(使用说明).................. . (6)三、测试报告1、测试用例.................. .... . (6)2、测试结果.................. .... . (6)3、分析探讨.................. .... . (7)四、总结................ .... . (10)五、附录(源程序)...... ...... ... ......... ..10六、参考文献......... .... ......... ... . (16)章节安排:一、问题描述1、课程设计目的1.掌握单向循环链表的建立。
约瑟夫环-joseph环-数据结构与算法课程设计报告

合肥学院计算机科学与技术系课程设计报告2009~2010学年第二学期课程数据结构与算法课程设计名称joseph环学生姓名朱玉庭学号0804012029专业班级08计本(2)指导教师王昆仑、张贯虹2010 年06月08号一、问题分析和任务定义:约瑟夫环是一个数学游戏,根据游戏内容的描述,能够很容易的看出,游戏中的玩家顺时针围坐一圈,能够很容易的发现,这跟本课上的单循环链表非常相似,所以可以通过单循环链表存储结构模拟此过程,当游戏中的玩家出列时,可以通过删除单循环链表中的结点来实现。
二、数据结构的选择和概要设计:选择带为指针的单循环链表来解决这个问题,先建立一个空链表,然后根据人数生成具有相应结点的单循环链表,知道密码后,通过循环来找到对应的结点,然后将该结点的编号输出,改变密码,最后删除结点,以此类推,知道编码全部输完,即可得到结果序列。
三、详细设计和编码:本题目是通过单循环链表存储结构来模拟此过程的,首先要先明确该单循环链表中结点的结构类型,定义如下:typedef struct Node{int key; //每个人持有的密码int num; //这个人的编号struct Node *next; //指向下一个结点}Link;当生成单循环链表时,就需要用到课本上创建单循环链表的有关内容了,可以先通过子函数Link *InitList()建立一个空链表,返回指针L,然后将返回的指针代入子函数Link *Creater(Link *L,int n)的形参中,对循环链表进行初始化,并且也返回一个指针,然后再将这个返回的指针代入到输出函数void Output(Link *L,int n,int m)的形参中,要想根据题目要求完成序列的输出,需要通过两个for循环来实现,第一个循环for(i=1;i<=n;i++) ,因为一个用n个人,所以结果要输出n个编号,这个循环每循环一次输出一个编号即printf("%d ",q->num),并将该编号下的密码赋值给m 即m=q->key,当循环完毕时正好将编号全部输出,第二个循环for(j=1;j<m;j++) p=p->next; q=p->next; 用以找到相应的结点,并用指针q指向它,当完成了编号的输出和密码的赋值后,删除q指向的结点,将两个循环适当结合,即可输出正确的结果序列,其中的人数n和初始密码在主函数中确定。
Removed_数据结构约瑟夫环课程设计报告书

:50 45. 44. 43. by 42.41.— 4—0.— 3—9.—3—8.by37@.—— 36.35. —34—. ——33.312. 1.2.3.34.0.5.6—.—29.by28.by@27.26.—— 25. 24. 23. 22. by 21.20. — 1—9.by:18.by:17.— 1—6.— 1—5.—1—4.—— 13. 12. 111.0“. ”by: 9M.“OOOKN”b8y.:——7.——6.——5.——4.——3.——2.——1.——
s=(LNode *)malloc(sizeof(LNode)); if (L==0) p=s; if (n==start) t=s; s->data=n; s->next=L; L=s; n--; } p->next=L; return t; } LNode* GetNode(LNode *p)/*出队函数*/ { LNode *q; for (q=p;q->next!=p;q=q->next); q->next=p->next; free (p); return (q); }
其次,建立一个不带头结点的循环链表并由头指针 p 指示。
最后,设计约瑟夫环问题的算法。
1、工作指针 first,r,s,p,q 初始化
2、输入人数(n)和报数(m)
3、循环 n 次,用尾插法创建链表
int start=k-1; LNode *s,*p,*L=0,*t; if (start==0) start=n; while (n!=0) { s=(LNode *)malloc(sizeof(LNode)); if (L==0) p=s; if (n==start) t=s; s->data=n; s->next=L; L=s; n--; } p->next=L; return t; } LNode* GetNode(LNode *p)/*出队函数*/ { LNode *q; for (q=p;q->next!=p;q=q->next); q->next=p->next; free (p); return (q); }
约瑟夫环问题课程设计报告

数据结构课程设计报告设计课题:约瑟夫问题院系:计算机科学与技术学院专业班级:计算机网络技术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 功能剖析约瑟夫环问题是一个古老的数学识题,本次课题要求用程序语言的方式解决数学识题。
数据结构课程设计Joseph环

编号是1,2,……,n的n个人按照顺时针方向围坐一圈,每个人只有一个密码(正整数)。一开始任选一个正整数作为报数上限值m,从第一个人开始顺时针方向自1开始顺序报数,报到m时停止报数。报m的人出列,将他的密码作为新的m值,从他在顺时针方向的下一个人开始重新从1报数,如此下去,直到所有人全部出列为止。设计一个程序来求出出列顺序。
I=*k;Operate(I,m,n);}
3、 函数的调用关系图为:
是 否
是否
测试
参加的人数为:3
起始报数上线值:2
输入第1个人的密码:4
输入第2个人的密码:5
输入第3个人的密码:6
输出结果为:
第1个出列的人的编号是:2 密码是:5
第2个出列的人的编号是:3 密码是:6
最后一个出局的人的编号是:1 密码是:4
inti=1,j;
LinkList J;
for(i=1; i<n; i++)
{
for(j=1; j<h; j++)
{
J=L;
L=L->next;
}//找出第m个元素
J->next=L->next;//将其删除
printf("第%d个出列的人的编号是:%d密码是:%d\n",i,L->data,L->password);
q=(*L);
q->next=NULL;
for(i=1;i<=z;i++)
{
p=(LinkList) malloc (sizeof(LNode));//建立一个linklist型的指针
q->next=p;
p->next=NULL;
约瑟夫环课程设计报告

课程设计报告课程设计名称:数据结构课程设计课程设计题目:约瑟夫环院(系):专业:班级:学号:姓名:指导教师:目录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、实现约瑟夫环数据出列顺序的算法:依照题目要求按照报数上限对节点进行查找和删除操作,按顺序输出出列的节点序号,依照每次出列的节点存储的密码修改报数上限循环操作直到全部节点出列完毕程序运行结束。
数据结构课程设计约瑟夫环

《数据结构》课程设计报告书题目:约瑟夫环系别:计算机科学与应用学号:学生姓名:指导教师:完成日期:2012年6月7日目录1.需求分析 (3)1.1 功能分析 (3)1.2开发平台 (3)2.概要设计 (3)3. 程序设计主要流程 (5)4.调试与操作说明 (5)4.1调试情况 (5)4.2操作说明 (6)总结 (8)致谢 (9)附录 (9)参考文献 (13)指导教师评语: (14)1.需求分析1.1 功能分析本次选做的课程设计是改进约瑟夫(Joseph)环问题。
约瑟夫环问题是一个古老的数学问题,本次课题要求用程序语言的方式解决数学问题。
此问题仅使用单循环链表就可以解决此问题。
在建立单向循环链表时,因为约瑟夫环的大小由输入决定。
为方便操作,我们将每个结点的数据域的值定为生成结点时的顺序号和每个人持有的密码。
进行操作时,用一个指针r指向当前的结点,指针H指向头结点。
然后建立单向循环链表,因为每个人的密码是通过scanf()函数输入随机生成的,所以指定第一个人的顺序号,找到结点,不断地从链表中删除链结点,直到链表剩下最后一个结点,通过一系列的循环就可以解决改进约瑟夫环问题。
1.2开发平台WindowsXP操作系统;Microsoft Visual C++ 6.0;2.概要设计编号为1,2… n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数的上限值m,从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的顺时针方向上的下一个开始重新从1报数,如此下去,直至所有人全部出列为止,设计一个程序求出出列顺序。
这个问题采用的是典型的循环链表的数据结构,就是将一个链表的尾元素指针指向队首元素。
r->next=H。
解决问题的核心步骤:首先建立一个具有n个链结点,无头结点的循环链表。
然后确定第1个报数人的位置。
最后不断地从链表中删除链结点,直到链表为空。
(完整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、本演示程序中,利用单向循环链表存储结构模拟约瑟夫问题的进行。
程序运行后,首先要求用户指定初始报数上限值,然后读取个人的密码。
可设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)。
数据结构课程设计报告(约瑟夫问题)

数据结构课程设计报告(约瑟夫问题)问题描述约瑟夫问题:编号为1-n的n个人围坐圆桌旁,从任一指定编号为k的人开始报数,报数为m的人离开圆桌,下一个人接着从n开始报数, 报数为m的人又离开圆桌,依此重复,直至所有人离开圆桌.编一程序,输出离开圆桌的人的编号序列.设计思想首先采单循环链表建立整个约瑟夫环,手动输入总人数(既链表的长度)、每个人的所持下一轮报数出对值和初始报数值。
node->num为人的编号,node->为此人所持的下一轮报数值。
建立单循环链表后,通过初始报数值找到出列的人,输出node->num的值,然后将该结点中的data值作为下一轮的报数值。
重复以上过程直至所有的人都出列,则程序结束。
主要算法do{k=1;while(k!=m)//当k=m时,结束第一轮报数{p1=p1->next;k++;}//报数中将指针指向下一位p2=p1->next;p1->next=p2->next;//把报数为m的人的结点从链表中删除printf("编号为%d的人出列,他的key%d作为新的m值/n",p2->num,p2->data);//m=p2->data;//报数为m的人的密码作为下一轮新的m值free(p2);//释放报m的人的结点}while(p1->next!=p1);//当p1->指向自己时,报数结束的值加一,当k=m时,此时p1指向人出列,p2指向该结点的上一结点,k为计数器,指针每移动一次,k让上一结点的next指向该结点的下一结点,然后删除该结点。
P1指向该结点下一结点,令k=1,再开始下一轮报数。
等到所有人出列后,循环结束。
for(i=1;i<=n;i++){printf("请输入%d号同学的key",i);scanf("%d",&j);//输入学生所带有的密码p1->next =(listnode*)malloc(sizeof(listnode));//建立一个空间p1=p1->next ;p1->data=j;p1->num=i;//对结点的num和data成员赋值p1->next=head->next; }定义指针p1,然后建立一个新结点并将p1->next指向他,再将地址赋给p1,最后将head->next赋给p1->next,构成了循环单链表,然后让所有人键入链表并给num和data成员赋值。
数据结构课程设计报告-约瑟夫环问题

华北科技学院课程设计说明书班级: 姓名:____设计题目: 约瑟夫环设计时间:____2011-2-28 至__2011-3-11指导教师:评语:_________________________________ _________________________________________ _________________________________________ _________________________________________ _________________________________________ 评阅成绩:____评阅教师:_____一、设计题目与要求设计题目:约瑟夫环问题描述:编号为1,2… n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数的上限值m,从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的顺时针方向上的下一个开始重新从1报数,如此下去,直至所有人全部出列为止,设计一个程序求出出列顺序。
基本要求:1、利用单循环链表作为存储结构模拟此过程;2、键盘输入总人数、初始报数上限值m及各人密码;3、显示游戏中队形及各人密码变化过程;4、按照出列顺序输出各人的编号。
二、概要设计实验设计思路:1.以无头结点的单循环链表为存储结构模拟此过程。
2.键盘录入各各同学所持密码,存储在一维数组a[]中。
3.单循环链表初始化时,将密码和编号存入结构体中。
4.进行单链表删除操作,直到链表为空,输出的编号存入数组b[]中5.依次输出b[]中的元素。
程序结构:本程序是单文件程序,构成的函数有LinkedList LinkedListInit(int n,int a[]) 初始化循环单链表void LinkedListTraverse(LinkedList L) 遍历单链表void Play(LinkedList L,int m,int b[],int n) 单循环链表的删除void main() 主函数,输出出队序列其中,void Play()是最主要的函数,初始化单链表后,开始执行该函数,指针按给定的密码值m依次后移m次删除定位后的结点,输出编号,同时获得新的m 值,继续循环,直到该链表为空。
约瑟夫环与八皇后问题--数据结构课程设计实验报告

录 问题描述 1 问题分析 1 数据结构描述 算法设计 2 详细程序清单 程序运行结果 心得体会 12
1 4 11
一、 问题描述 1. 约瑟夫问题描述 编号为1,2... n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。一 开始任选一个正整数作为报数的上限值m,从第一个人开始按顺时针方向自1开始顺序报 数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的顺时针方向上的 下一个开始重新从1报数,如此下去,直至所有人全部出列为止,设计一个程序求出出列 顺序。 2. 八皇后问题描述 在一个8×8的棋盘里放置8个皇后,要求每个皇后两两之间不相"冲"(在每一横 列竖列斜列只有一个皇后)。 3、界面设计模块问题描述 设计一个菜单式界面,让用户可以选择要解决的问题,同时可以退出程序。界面要 简洁明了,大方得体,便于用户的使用,同时,对于用户的错误选择可以进行有效的处 理。 二、 问题分析 在整个课程设计中,我主要负责的是约瑟夫问题中链表中的出列的操作算法的设计。 用循环单链表表示编号为1,2... n的n个人按顺时针方向围坐一圈,每人持有一个密码 (正整数)。一开始输入一个正整数作为报数的上限值turn,从第一个人开始按顺时针方 向自1开始顺序报数(即从第一个结点开始指针向后移动),报到turn-1时(即指针指向 turn-1个结点时)停止,他的下一位出列,将他的下一位密码作为新的turn值,从出列的 人的的顺时针方向上的下一个开始重新从1报数,如此下去,直至链表中只剩一位(即一 个结点)退出循环,并所有人的编号按出列顺序输出。在实现的过程中定义i表示报数的
int code; struct LNode *next; }node,*linklist; linklist creatstart(linklist L,int number) { int m,i; linklist s,p; s=L; for(i=1;i<=number;i++) { p=(linklist)malloc(sizeof(node)); if(!p) exit(0); p->data=i; printf("please input the code of number %d:",i); scanf("%d",&p->code); p->next=NULL; s->next=p; s=p; } s->next=L->next; return s; } void chulie(linklist L,int number) { int turn,i,j; linklist p,s; printf("please input the start code:"); scanf("%d",&turn); p=L; printf("the turn out of the circle is:"); for(i=1;i<=number-1;i++) { for(j=1;j<=turn-1;j++) p=p->next; printf("%d ",p->next->data); turn=p->next->code; s=p->next; p->next=s->next; free(s); } printf("%d ",p->next->data); printf("\n"); } void lianbiao() { int number; linklist L; L=(linklist)malloc(sizeof(node));
约瑟夫环问题 实验报告完整版

对任意 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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》课程设计报告书设计题目:约瑟夫环专业:班级:姓名:指导教师:完成日期:目录一、问题描述 (1)二、基本要求 (1)三、测试数据 (1)四、算法思想 (2)五、模块划分 (3)六、数据结构 (4)七、源程序 (4)八、界面设计 (6)九、运行与测试 (6)十、总结 (8)十一、思考与感悟 (9)课程设计设计报告书一、问题描述约瑟夫问题是由古罗马著名的史学家Josephus提出的问题演变而来,所以通常称为Josephus问题。
改进约瑟夫问题的描述是:编号为1,2,…,n的n个人按顺时针方向围坐一圈, 每人有一个密码(整数),留作其出圈后应报到后出圈。
报数方法采用顺时针报数和逆时针报数交替进行,初始密码可任意确定。
求最后剩下的人的编号。
这个就是约瑟夫环问题的实际场景,后来老师要求我们对要求中的每人所持有的密码以及第一次的报数上限值要用随机数产生。
因此约瑟夫环问题如果采用双向循环链表则能很好的解决。
循环链表的数据结构,就是将一个链表的尾元素指针指向队首元素。
p->link=head解决问题的核心步骤:先建立一个具有n个链结点,无头结点的循环链表,然后确定第一个报数人的位置,并不断地从链表中删除链结点,直到链表为空。
二、基本要求(1)输入的形式和输入值的范围:输入的形式是以数字的形式输入,输入范围为-2147483648~2147483648(2)输出的形式:字符串形式输出(3)程序所能达到的功能:达到符合约瑟夫环要求的响应功能。
三、测试数据进入程序,显示“1.开始游戏0.退出游戏”输入非0数进入游戏,输入0退出游戏。
进入游戏后显示“输入总人数”,输入大于0的整数;若输入错误,则光标处清空,重新输入。
后提示“输入开始人的序号”;范围是大于零,小于总人数的整数,若输入错误,则光标处清空,重新输入。
后提示“输入间隔数字”,范围是任意正整数;若输入错误,则光标处清空,重新输入。
按回车键,显示结果,并重新询问“1.开始游戏0.退出游戏”。
四、算法思想首先,设计实现约瑟夫环问题的存储结构。
由于约瑟夫环本身具有循环性质,考虑采用循环链表,为了统一对表中任意节点的操作,循环链表不带头结点。
循环链表的结点定义为如下结构类型:typedef struct node{int data;struct node *next;}LNode;其次,建立一个不带头结点的循环链表并由头指针p指示。
最后,设计约瑟夫环问题的算法。
1、工作指针first,r,s,p,q初始化2、输入人数(n)和报数(m)3、循环n次,用尾插法创建链表int start=k-1;LNode *s,*p,*L=0,*t;if (start==0) start=n;while (n!=0){s=(LNode *)malloc(sizeof(LNode));if (L==0) p=s;if (n==start) t=s;s->data=n;s->next=L;L=s;n--;}p->next=L;return t;}LNode* GetNode(LNode *p)/*出队函数*/{LNode *q;for (q=p;q->next!=p;q=q->next);q->next=p->next;free (p);return (q);}4、输入报数的起始人号数k;5、循环n次删除结点并报出位置(其中第一个人后移k个)当i<n时移动指针k-1次s->next=L;删除p结点的后一结点qq=p;q->next!=p;q=q->nextq->next=p->next;报出位置后free q;计数器i++;五、模块划分图5-1 流程关系图六、数据结构通过对问题的分析,给出该课程设计需要使用的数据结构的类型定义,并阐述定义理由。
存储结构:循环链表图6-1循环链表七、源程序#include <stdlib.h>#include <stdio.h>typedef struct node{int data;struct node *next;}LNode;main(){LNode* Create(int,int);LNode* GetNode(LNode *);int Print(LNode *,int);LNode *p;int n,k,m;int flag;while(1){printf("1.开始游戏0.退出游戏\n");scanf("%d",&flag);if(!flag) break;do{printf ("输入总人数");scanf ("%d",&n);}while (n<=0);do{printf ("输入开始人的序号(1~%d)",n);scanf ("%d",&k);}while (k<=0 || k>n);do{printf ("输入间隔数字");scanf ("%d",&m);}while(m<=0);p=Create(n,k);Print(p,m);}return 0;}LNode* Create(int n,int k)/*创建循环链表*/ {int start=k-1;LNode *s,*p,*L=0,*t;if (start==0) start=n;while (n!=0){s=(LNode *)malloc(sizeof(LNode));if (L==0) p=s;if (n==start) t=s;s->data=n;s->next=L;L=s;n--;}p->next=L;return t;}LNode* GetNode(LNode *p)/*出队函数*/{LNode *q;for (q=p;q->next!=p;q=q->next);q->next=p->next;free (p);return (q);}Print(LNode *p,int m)/*输出函数*/{int i;printf ("出队编号:\n");while (p->next!=p){for (i=1;i<=m;i++)p=p->next;printf ("%d ",p->data);p=GetNode(p);}printf("%d\n",p->data);return 0;}八、界面设计1.开始游戏0.退出游戏1输入总人数:7输入开始人的序号(1~7):1输入间隔数字:3出对编号:3 6 2 7 5 1 41.开始游戏0.退出游戏Press any key to continue九、运行与测试图9-1 开始界面图9-2 输入总人数图9-3 输入开始人的序号图9-4 输入间隔数字图9-5 结果输出图9-6 退出界面十、总结调试时出现的问题及解决办法:利用带头结点的尾插法建立链表求解的时候,头节点的作用无法确定,导致编译通过,但是运行之后的结果都不是正确的运行结果。
苦苦思索,包括和同学讨论,一直没能解决,最后决定改用另一种存储方法,将头节点直接改成NULL,最终测试的结果是正确的。
(但是还未能完全理解原因是什么)用函数返回存储节点的地址的时候,函数中的一句没有问题的语句出现访问错误,更改函数从而解决了问题。
《数据结构》课程设计报告书十一、思考与感悟通过这次数据结构课程设计,我感受最深的就是对于循环链表的使用,可以说对循环链表有了比以前更进一步的认识,以前只是一知半解的,如果只给个题目自己根本不能把程序完整地编写出来,所以这次课程设计最大的收获就在于对循环链表有了一定的理解,包括其中的一系列操作,如建立一个循环链表,删除链表中的一个结点,增加一个结点等。
在这次课程设计过程中需要我们一边设计一边探索,这这个过程当中我发现自己在数据结构方面知识掌握不够深入,对一些基本概念不能很好的理解,对一些数据结构不能够熟练的进行上机实现,这是自己比较薄弱的。
学好基础知识是理论付诸实践的前提,这样理论和实践才能充分地结合起来。
在以后的学习中,我还要努力改正,充分利用上机实验的机会提高自己。
在程序的输入的时候,因为自己对键盘的不熟练,代码又很多很繁琐,常常会产生放弃的念头,从中我也感受到只有坚持到底,胜利才会出现。
在调试程序的时候我也有所体会,虽然约瑟夫环问题不是很难,但调试的时候还是会出现很多错误,因此我们不能认为容易就不认真对待。
在以后的学习中,要能不断发现问题,提出问题,解决问题,从不足之处出发,在不断学习中提高自己。
9。