数据结构课程设计报告约瑟夫环完整版[1]

合集下载

约瑟夫环问题实验报告

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.调试分析在本次试验调试中很不顺利。

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

基础成绩：82分《数据结构》课程实验实验报告题目：Joseph问题求解算法的设计与实现专业：网络工程班级：网络102姓名：***学号： ******完成日期：2012/6/20一、试验内容-约瑟夫（Joseph）问题的一种描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。

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

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

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

二、试验目的掌握链表的基本操作：插入、删除、查找等运算，能够灵活应用链表这种数据结构。

三、流程图struct list{-int num,code;struct list *next;};void main(){printf("Joseph问题求解算法的设计与实现\n \n");int i,j,m=1;int key; // 密码.int n; //人数.list *p,*s,*head;head=(list *)malloc(sizeof(list)); //为头结点分配空间.p=head; //使指针指向头节点printf("输入人的总个数:");scanf("%d",&n);for(i=1;i<=n;i++){printf("第%d个人的密码:\n",i);scanf("%d",&key);s=p;p=(list *)malloc(sizeof(list)); //创建新的结点.s->next=p;p->num=i;p->code=key;}p->next=head->next;p=head;head=head->next;free(p); //释放头结点.p=head;printf("\n\n输入初始值:\n");scanf("%d",&key);printf("\n出列顺序为:\n");do{ j=1; p=head;while(j<key){s=p;p=p->next;//使P指向下一结点j++;} //报数过程.i=p->num;key=p->code;printf("%d\n",i);s->next=p->next;-head=p->next; //重新定义head,下次循环的开始结点.free(p);// 释放已出列的结点.n--; //人数减一.}while(n>0);int x;printf(“输入0退出：”);scanf(“%d”,&x);for(;;){if(x==o)break;}}五、调试过程调试过程中,曾出现过缺少分号、括号之类的错误,还出现过运算顺序颠倒，致使运算出现了错误，在经过仔细的检查并且向人请教,终于得出了正确结果.六、结果分析输入人数：7 输入密码：3 1 7 2 4 8 4 初值：6排序结果：6 1 4 7 2 3 5。

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

数据结构上机实验报告1、需求分析1：用一个循环链表实现n个人按顺时针排成一圈,每个人看作一个节点,每个节点都是一个结构体类型,包含三个域: 序号域(data), 密码域(key),指向下一个人的指针域(next).2：程序开始时由用户任意输入人数n及一个正整数作为报数上限值m,一个正整数作为密码最大值，判断所输密码是否在范围内。

然后为依次每一个人指定一个密码3：初始密码为用户外部输入的密码m, 从第一个人开始按顺市针方向自1开始报数.,报道m的时停止,报m的人出列,将他的密码作为新的密码值(m), 从他在顺针方向的下一个人开始重新从1报数,如此下去,直至所有的人全部出列为止.4：本程序最终结果为n 的人的出列顺序5：测试数据: m的初值为1; n =5(即有5个人)57个人的密码依次为:1，2，3,4，5.首先没的值为1,正确的出列顺序应为1，2，4，3，5。

2概要分析（1）抽象数据类型的定义：为实现上述程序的功能，可以用整数存储用户的输入。

并将用户输入的值存储于线性表中。

算法的基本思想：约瑟夫环问题中的数据是人所在的位置，而这种数据是存在“第一元素、最后元素”，并且存在“唯一的前驱和后继的”，符合线性表的特点。

由于需要模拟约瑟夫环的出列问题，可以采用顺序表来实现线性表，完成出列顺序的输出。

核心算法主要分为两步：1、确定需要删除的位置，2、设置并删除该位置。

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

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

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

（2）主程序的流程：程序由三个模块组成：（1）输入模块：无提示语句，直接输入总人数n和报数次数m，中间用逗号隔开。

（2）构造链表并输入每个人信息模块：（3）主要处理出列的函数：分别在DOS下和文件中，按移除元素的顺序依次显示其位置。

实验报告1约瑟夫环

《数据结构》实验报告班级：姓名：学号：日期：08-10-20题目：约瑟夫环一、上机实验的问题和要求：问题描述：编号为1到n的n个人围成一圈，每人带一个密码c，以m为报数上限。

然后从第一个人开始顺时针自1开始报数，报到m的人出列，将其密码作为新的m值，从他的下一个人开始，同样顺时针自1开始报数，依次循环下去，直到所有的人都出列！要求得到依次出列的那些人的编号序列！基本要求：用C代码实现此活动，要求使用一定的算法进行操作，并最终通过程序运算出最后的结果！二、程序设计的基本思想，原理和算法描述：（包括程序的模块结构，数据结构，输入/输出设计，符号名说明等）基本思想：利用不带头结点单向循环链表模拟该活动，在实现了一切动作之后，运用一定的算法得到最终的结果。

程序的模块结构：定义了相关的结构体之后，主要有以下几大模块：1.建立由头指针指示的有n个结点的不带头结点的单向循环链表crt_CLinkList(H,n);2.寻找、输出、删除H单循环链表的第m个结点locfor(H,m);3.最后通过main函数体处理参数的输入与显示，并调用以上两函数，最终解决问题。

主要数据结构：单链的循环链表，即线性表的链式存储结构。

算法的伪码描述：结构体定义如下：typedef struct Lnode /*定义单链表*/{int number; /*编号*/int cipher; /*密码*/struct Lnode *next; /*指针*/}Lnode,*CLinklist; /*重定向命名*/CLinklist H; /*Ｈ为全局单链表*/算法的实现详见源程序。

输入/输出设计本程序并未采用任何二进制文件出入的方式，这点说明将在最后总结提到。

至于函数的出入口问题，在源程序及注释中将得到详细说明，这里不再赘述。

三、源程序及注释：(说明函数功能、入口及出口参数,其他)#include <stdio.h> /* 头文件*/#include <stdlib.h>#include <alloc.h>typedef struct Lnode /*定义单链表*/{int number; /*编号*/int cipher; /*密码*/struct Lnode *next; /*指针*/}Lnode,*CLinklist; /*重定向命名*/CLinklist H; /*Ｈ为全局单链表*/struct Lnode *crt_CLinkList(CLinklist H,int m) /*创建一个不带头结点的单向循环链表*/{ /*其中，Ｈ为全局单链表，m为链表结点总数*/ int i; /*循环记数用*/struct Lnode *ptr1; /*用于索引*/if((ptr1=(struct Lnode *)malloc(sizeof(struct Lnode)))==NULL) /*一旦动态内存分配失败，报错退出！*/ {perror("malloc");return ptr1;}H=ptr1; /*形成单个结点的单循环链表*/ptr1->next=H;for(i=1;i<m;i++) /*形成m个结点的不带头结点的单循环链表*/ {if((ptr1->next=(struct Lnode *)malloc(sizeof(struct Lnode)))==NULL){perror("malloc");ptr1->next=H;return H;}ptr1=ptr1->next; /*其中Ｈ指头，ptr指尾*/ptr1->next=H;}return H; /*返回成功新建的单链表Ｈ*/}void locfor(CLinklist H,int m) /*寻找输出删除链表Ｈ中的第m个结点*/{ /*H为全局链表，m为要查找删除的结点位置*/ int i; /*循环计数*/struct Lnode *ptr;for(i=1;i<=5;i++) /*考虑图形界面的美观问题*/printf("number\tcipher\t");i=1; /*初始化*/while(H->next!=H) /*只剩单个结点时停止循环，进行最后输出！*/ {if(m==1) /*考虑进行自身删除的情况，即m=1*/{for(ptr=H->next;ptr->next!=H;ptr=ptr->next);/*正因为是自身删除才要费大劲寻找其父结点*/printf("%-6d\t",H->number); /*找到后，先输出*/printf("%-6d\t",H->cipher);m=H->cipher; /*确定下一次寻找的m值*/ptr->next=H->next; *删除结点，即自身结点*/ptr=ptr->next;free(H); /*因为对于链表中的结点，每个之前都分配了内存，所以free是必要的*/H=ptr; /*不同于以下普通结点的删除，自身删除还要还原H*/i=1; /*i重置，以方便下一次的循环操作*/}else if(i==m-1) /*因为从自身开始即为1号，因为m-1,而不是m*/{ptr=H->next; /*结点的删除操作同于上面的情况!*/printf("%-6d\t",ptr->number);printf("%-6d\t",ptr->cipher);m=ptr->cipher;H->next=ptr->next;H=H->next;free(ptr);i=1;}else{H=H->next; /*若未找到，则继续遍历！*/i++;}}printf("%-6d\t",H->number); /*对于单个结点的单循环链表，进行最终的输出操作！*/ printf("%-6d",H->cipher);free(H); /*完成所有任务并释放所有内存占用！*/}void main() /*主函数接口*/{ /*调用所有函数，进行实验模拟，并得出实验结果！*/ int i,j,n=30,m,k;struct Lnode *ptr;randomize(); /*因为下面调用了random函数，故此处的初始化很有必要！*/ printf("Now the experiment will begin.You have two choices!\n");/*数据输入可以电脑随机，也可以自行输入*/printf("If you want to enter the datas all by yourself,please enter 1.\n");/*自行输入（方便检测程序问题）*/ printf("If you want to get the datas by the computer,please enter 0.\n"); /*电脑随机产生数据*/printf("Now your choice:"); /*用户选择*/scanf("%d",&j);while(j!=0&&j!=1) /*考虑程序的完善性，对于误输入的提示并报警！*/ {printf("\nYou enter is unillage!Please try again!\n");printf("Now your choice:"); /*重新输入*/scanf("%d",&j);}H=crt_CLinkList(H,n); /*初始化链表*/if(j==0) /*电脑随机充入数据*/for(i=1;i<=30;i++){H->number=i;H->cipher=rand(); /*随机函数*/H=H->next;}else /*此时选择实验者输入数据！*/{for(i=1;i<=30;i++){H->number=i;printf("Now number %d,please enter the cipher:",i);scanf("%d",&k);H->cipher=k;H=H->next;}}m=rand(); /*默认情况下，m随机产生*/printf("Do you want to enter the number m?Enter 1 to set or others cancel!\n");/*当然，如果想自已输，可以进行覆盖*/scanf("%d",&k);if(k==1) /*自行输入m值*/{printf("Please enter the number m:");scanf("%d",&m);}system("cls"); /*考虑屏幕大小，进行分屏显示*/printf("All followed are your datas!\n"); /*界面友善*/for(i=1;i<=5;i++)printf("number\tcipher\t");for(i=0;i<30;i++) /*显示所有处理前数据*/{printf("%-6d\t",H->number);printf("%-6d\t",H->cipher);H=H->next;}printf("And the number m is :%d\n",m);printf("\nAfter the program,the result is:\n");locfor(H,m); /*对所有数据进行实验处理，直至所有结点处理完！*/ getchar();printf("\nPress any key return!"); /*TC环境下，方便查看结果！*/getchar();}四、用户使用说明与测试运行结果：1．运行程序后，首先弹出界面，截图如右：理性化的选择：如果打1，则所有的cipher均由用户输入，这样方便对特殊数据进行程序测试！如果打0，那么所有的数据均由电脑产生！那如果打其他的呢？考虑到误输入，加了一个循环，以提高程序的健壮性！2．首先自行输入数据进行测试。

约瑟夫环-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和初始密码在主函数中确定。

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

《数据结构与算法设计》约瑟夫环实验报告——实验一专业：物联网工程班级：物联网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、细节决定成败，编程最需要的是严谨，如何的严谨都不过分，往往检查了半天发现错误发生在某个括号，分号，引号，或者数据类型上。

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

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

此问题仅使用单循环链表就可以解决此问题。

而改进的约瑟夫问题通过运用双向循环链表，同样也能方便地解决。

在建立双向循环链表时，因为约瑟夫环的大小由输入决定。

为方便操作，我们将每个结点的数据域的值定为生成结点时的顺序号和每个人持有的密码。

进行操作时，用一个指针current 指向当前的结点，指针front 始终指向头结点。

然后建立双向循环链表，因为每个人的密码是通过rand()函数随机生成的，所以指定第一个人的顺序号，找到结点，不断地从链表中删除链结点，直到链表剩下最后一个结点，通过一系列的循环就可以解决改进约瑟夫环问题。

图2 约瑟夫环原理演示图二、概要设计1、循环链表抽象数据类型定义typedef struct LNode//定义单循环链表中节点的结构{int num;//编号int pwd;//passwordstruct LNode *next;//指向下一结点的指针}LNode;2、本程序包含一下几个模块（1）构造结点模块LNode *createNode(int m_num,int m_pwd){LNode *p;p=(LNode *)malloc(sizeof(LNode));//生成一个结点p->num=m_num;//把实参赋给相应的数据域p->pwd=m_pwd;p->next=NULL;//指针域为空return p;}（2）创建链表模块void createList(LNode *ppHead,int n)（3）出队处理模块void jose(LNode *ppHead,int m_pwd)（4）约瑟夫环说明输出模块void instruction()（5）菜单模块void menu()（6）主函数模块int main（）函数的调用关系图如下：三、详细设计1.主函数图4 主函数数据流程图根据流程图，主函数程序如下：int main(){int n,m,x;LNode *ppHead=NULL;menu();for(;;){printf("\n请选择要执行的操作：");scanf("%d",&x);system("cls");switch(x){case 1:printf("************************************************************ ****\n");printf("约瑟夫环:\n");printf(" 编号为1,2,3,4…,n的n个人按顺时针方向围坐一圈,每人持有一个密\n");printf("码(正整数).一开始任选一个正整数作为报数的上限值m,从第一个人开始\n");printf("按顺时针方向自1开始顺序报数,报到m时停止.报m的人出列，将他的密码\n");printf("m作为新的m值,从他在顺时针方向上的下一人开始重新从1报数,如此下去,\n");printf("直到所有人全部出列为止.编程打印出列顺序.\n");printf("************************************************************ ****\n");main();break;case 2:printf("\n请输入总人数n：");scanf("%d",&n);printf("请输入开始上限数m：");scanf("%d",&m);createList(&ppHead,n);printf("\n");printf("出队顺序：\n");jose(ppHead,m);printf("\n约瑟夫环游戏结束!\n");main();break;case 0:exit(0);default:system("cls");printf("\n您选择的操作有误，请重新选择...\n\n\n");main();}}return 0;}2.链表的创建图5 创建链表函数的数据流程图/*创建单向循环链表ppHead，人数个数为n，并输入每个人的密码值，若建立失败则生成头结点，让cur指向他，若建立成功则插入结点P，cur指向的数据元素为p,后续为"空"的节点，再把P插入循环链表ppHead中*/根据流程图，创建链表函数程序如下：void createList(LNode **ppHead,int n){int i,m_pwd;LNode *p,*cur;//cur:浮标指针for(i=1;i<=n;i++){printf("输入第%d个人的密码：",i);scanf("%d",&m_pwd);//输入持有密码p=createNode(i,m_pwd);//调用构造结点函数if(*ppHead==NULL)//如果头结点为空{*ppHead=cur=p;//生成头结点，让cur指向他cur->next=*ppHead;//cur的指针域指向自身}else//如果不为空，则插入结点{p->next = cur->next;cur->next = p;cur= p;//cur指向新插入结点}}printf("完成创建！\n"); //提示链表创建完成}3.出队处理图6 出队函数的数据流程图/*p指向要删除节点的前一个节点，ppHead指向要删除的节点，使p=ppHead，ppHead再指向要删除节点的下一个节点，使p和ppHead链接，输出p指向节点的编号和密码值，释放ppHead，如此循环，直至把所有节点都打印和删除为止！*/根据流程图，出队函数程序如下：void jose(LNode *ppHead,int m_pwd){int i,j;LNode *p,*p_del;//定义指针变量for(i=1;p!=ppHead;i++){for(j=1;j<m_pwd;++j){p=ppHead;//p赋值为ppHead，p指向要删除结点的前一个结点ppHead=ppHead->next;//ppHead指向下一个元素}p->next = ppHead->next;//p结点与头结点链接i=ppHead->pwd;//i赋值为ppHead->pwdj=ppHead->num;//j赋值为ppHead->num，j为要删除的密码值printf("第%d个人出列，密码：%d\n",j,i);m_pwd=ppHead->pwd;//m_pwd赋值为ppHead->pwdfree(ppHead);//释放头结点ppHead=p->next;//ppHead重新赋值给p->next,即释放前的ppHead->pwd指针//删除报数结点}i=ppHead->pwd;//i赋值为ppHead->pwdj=ppHead->num;//j赋值为ppHead->numprintf("最后一个出列是%d号，密码是:%d\n",j,i);free(ppHead);//释放头结点}4. 约瑟夫环说明模块void instruction(){printf("************************************************************ ****\n");printf("约瑟夫环:\n");printf(" 编号为1,2,3,4…,n的n个人按顺时针方向围坐一圈,每人持有一个密\n");printf("码(正整数).一开始任选一个正整数作为报数的上限值m,从第一个人开始\n");printf("按顺时针方向自1开始顺序报数,报到时停止.报m的人出列，将他的密码\n");printf("m作为新的m值,从他在顺时针方向上的下一人开始重新从1报数,如此下去,\n");printf("直到所有人全部出列为止.编程打印出列顺序.\n");printf("******************************************************\n");return 0;}5. 菜单模块void menu(){printf("**************************约瑟夫环*****************************\n");printf(" \n");printf(" [1]约瑟夫环问题的阐述\n");printf(" [2]按要求求解约瑟夫环\n");printf(" [0]退出\n");printf("************************** 欢迎使用！****************************\n");}四、程序调试与测试1. 调用模块时，结点结构的调用与其他模块产生冲突，导致每一行都出现两次错误，加入子函数的声明后错误消失。

数据结构课程设计Joseph环

3设计任务
编号是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、实现约瑟夫环数据出列顺序的算法：依照题目要求按照报数上限对节点进行查找和删除操作，按顺序输出出列的节点序号，依照每次出列的节点存储的密码修改报数上限循环操作直到全部节点出列完毕程序运行结束。

(完整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个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。

基本要求：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 值，继续循环，直到该链表为空。

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

}
（2）约瑟夫环报数的算法在运行为循环方式，报数者除非本身已经出去，否则继续顺序报数，其报数循环的代码为
void Joseph(NODE *p,int number,int n)
{
int;=number; i++)
{
for(j=1; j<n-1; j++)
（2）基本要求
建立模型，确定存储结构。
对任意n个人，密码为m，实现约瑟夫环问题。
出圈的顺序可以依次输出，也可以用一个数组存储。
（3）思考：
采用顺序存储结构如何实现约瑟夫环问题？
如果每个人持有的密码不同，应如何实现约瑟夫环问题？
2.数据结构设计
由于约瑟夫环问题本身具有循环性质，考虑采用循环链表，为了统一对表中任意结点的操作，循环链表不带头结点。将循环链表的结点定义为如下结构类型：
5.运行测试与分析
（1）输出提示，如图1.2所示。
（2）根据提示，输入圈内人数n和每个人持有的密码m如图1.3所示。
（3）输出结果如图1.4所示
分析
6.实验收获及思考
通过该实验，我进一步增强了对于链表的理解，也对链表的操作和实现更为熟悉，熟练掌握了如何实现置空表、求表的长度、取结点、定位运算、插入运算、删除运算、建立不带头结点的单链表（头插入法建表）、建立带头结点的单链表（尾插入法建表），输出带头结点的单链表等操作。同时，锻炼了实际操作时的动手能力。
{
p=p->next;
}
q=p->next;
p->next=q->next;
p=p->next;
printf("第%3d个出圈的人是：%3d\n",i,q->value);

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

实验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）抽象数据类型的定义：为实现上述程序的功能，可以用整数存储用户的输入。