约瑟夫问题数据结构实验报告汇总.
约瑟夫环问题 实验报告
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; } 测试用例:
第3周实验报告——学习数据结构《约瑟夫序列》
实验3(第3周实验指导)约瑟夫序列一、实验题目求解《约瑟夫序列》的问题二、实验课时2课时。
三、实验目的1. 掌握“管理信息系统”书本第3章的相关内容2. 学习“单向链表”的数据结构及其有关操作3. 学习编写程序四、实验内容1.学习约瑟夫序列2.学习《约瑟夫序列》程序的例子(本例从一号开始报数)a) 3.作业: 编写程序求解以下问题, 现有运动会门票要赠与你们班(两个班各有67人, 学号从1到67)的10个幸运儿, 要求采用约瑟夫序列来抽签, 全班以学号顺序排号围坐在一张圆桌周围。
从编号为18的人开始顺序报数, 数到18的那个人出列;他的下一个人又从1开始报数, 数到18的那个人又出列;依此规律重复下去, 直到圆桌周围的剩下10个人就是幸运儿。
程序有如下要求:b)读取你们班名单文本文件的内容, 存入一个单向链表, 并以学号排序, 节点要求保存学号, 姓名和性别等信息。
c)针对这个链表进行以上的问题求解。
程序输出10个幸运儿的学号, 姓名, 性别五、实验报告要求1.独立完成, 作业交电子版2.给出程序源代码。
3.写出10个幸运儿的名字4.写实验心得或小结。
六、实验结果:程序源代码如下:#include <stdio.h>#include <stdlib.h>typedef struct node{int number;char info[100]; //将学生的学号, 姓名, 性别等信息都利用info[]来存储struct node *next;}dlnode,*dlink;struct node *head,*p,*temp1,*temp2;FILE *fp;struct node* Creatlist(int num) //创建班级列表{int i;head=(dlnode*)malloc(sizeof(dlnode));head->number=1;head->next=head;p=head;if((fp=fopen("calss2.txt","r"))==NULL) //打开存储学生信息的文本class2.txt{printf("\nCannot open file strike any key exit!");exit(1);}fgets(head->info,100,fp); //头结点可用于存储标题信息for(i=1;i<=num;i++){temp1=(dlnode*)malloc(sizeof(dlnode));temp1->number=i;fgets(temp1->info,100,fp); //将每个学生的信息导入入相应的info字符数组中,//每个学生对应一条info[]信息temp1->next=p->next;p->next=temp1;p=temp1;}p=head;printf("班级名单如下:\n");printf("序号学号姓名性别\n\n"); //printf(" %s\n",head->info);while(p->next!=head){printf(" %s\n",p->next->info);p=p->next;}return head;}void drowlots(dlnode *head,int num,int m) //主处理函数{int i,j;p=head;i=1;j=num;while(j!=10){if(i==m&&p->next!=head){temp2=p->next;//printf(" %d \n",temp2->number); //可输出被淘汰的学生的序号p->next=temp2->next;free(temp2);i=1;j=j-1;}else{if(p->next==head) i--;p=p->next;i++;}}p=head->next;printf("\n10名幸运儿如下:\n\n");printf("序号学号姓名性别\n\n");//printf(" %s\n",head->info);while(p!=head){printf(" %s\n",p->info);p=p->next;}}void main() //主函数{int n,m;n=67;head=Creatlist(n);printf("输入报数的编号: ");scanf("%d",&m);drowlots(head,n,m);syatem(“pause”);}运行结果:七、实验心得:本次实验所涉及的数据结构知识的难度并不高, 所涉及的程序主要用c语言编写, 在主处理函数drowlots()设计的时候, 思路比较清晰。
约瑟夫环问题实验报告
约瑟夫问题实验报告背景约瑟夫问题(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个数输出到屏幕上三.详细设计首先,设计实现约瑟夫环问题的存储结构。
实验报告 约瑟夫问题
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. 引言约瑟夫问题是一个经典的数学问题,描述了一个有n个人的圆桌围坐,从第一个人开始报数,报到m的人离开,然后从离开的人的下一个人开始重新报数,直到所有人离开。
在本实验中,我们将使用约瑟夫环数据结构来模拟这一问题,并分析其性能和适用场景。
2. 实验方法我们首先定义了一个约瑟夫环的数据结构,并实现了相应的插入、删除等操作。
然后,我们使用不同规模的数据集进行了实验,记录了每次操作的时间开销,并进行了性能分析。
3. 实验结果实验结果表明,约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率。
在不同规模的数据集下,其操作时间基本保持在可接受的范围内,并且随着数据规模的增加,性能表现基本保持稳定。
4. 结论约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率,并且可以应用于一定范围的实际问题中。
然而,在处理大规模数据时,仍需进一步优化算法和数据结构,以提高性能和效率。
5. 展望未来,我们将进一步研究约瑟夫环数据结构在实际问题中的应用,并探索其在其他领域的潜在价值。
同时,我们也将继续优化算法和数据结构,以提高其性能和适用范围。
综上所述,约瑟夫环数据结构在解决约瑟夫问题方面具有良好的性能和效率,并且具有一定的实际应用价值。
通过本实验,我们对该数据结构有了更深入的了解,并为其在实际问题中的应用提供了一定的参考和借鉴。
工作报告之约瑟夫环实验报告总结
约瑟夫环实验报告总结【篇一:约瑟夫环实验报告】实验报告课程名称:数据结构实验名称:顺序表和链表的应用实验编号:实验一指导教师:一、实验目的(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类,其中包含了创建环、添加元素、删除元素等操作。
实验实现1. 创建环在Josephus类中,我们首先需要创建一个循环链表。
我们使用一个头节点来表示环的起始位置。
在创建环的过程中,我们可以选择指定环的长度和起始位置。
2. 添加元素在创建环之后,我们可以通过添加元素来向约瑟夫环中插入数据。
我们可以选择在环的任意位置插入元素,并且可以动态地调整环的长度。
3. 删除元素根据约瑟夫环的规则,每次删除一个元素后,下一个元素将成为新的起始位置。
我们可以通过删除元素的操作来模拟约瑟夫环的运行过程。
在删除元素时,我们需要考虑环的长度和当前位置。
实验结果通过实验,我们得出了以下结论:1. 约瑟夫环数据结构可以有效地模拟约瑟夫环问题。
通过创建环、添加元素和删除元素的操作,我们可以模拟出约瑟夫环的运行过程,并得到最后剩下的元素。
2. 约瑟夫环数据结构具有一定的应用潜力。
除了解决约瑟夫环问题,该数据结构还可以用于其他类似的问题,如任务调度、进程管理等。
3. 约瑟夫环数据结构的时间复杂度较低。
由于约瑟夫环的特殊性质,我们可以通过简单的链表操作来实现该数据结构,使得其时间复杂度较低。
结论本次实验通过实现约瑟夫环数据结构,深入理解了该问题,并探索了其在实际应用中的潜力。
通过创建环、添加元素和删除元素的操作,我们可以模拟出约瑟夫环的运行过程,并得到最后剩下的元素。
约瑟夫环数据结构具有一定的应用潜力,并且具有较低的时间复杂度。
通过本次实验,我们对数据结构的设计和实现有了更深入的理解,并为将来的研究和应用奠定了基础。
数据结构约瑟夫环实习报告
数据结构约瑟夫环实习报告一、实习题目约瑟夫环(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值}}```五、实验结果与分析通过以上程序设计,我们可以得到约瑟夫环的出列顺序。
数据结构实验报告_约瑟夫环
typedef struct Node
{
int num;
int key;
struct Node *next;
}Node,*LinkList;
void main()
{
int n,m;
cout<<"请输入人数:";
cin>>n;
while(n<=0){
cout<<"人数不合法,请重新输入:";
{
cout<<p->num<<"号的密钥为"<<p->key<<endl;
p=p->next;
}
cout<<endl;
for(i=1;i<=n;i++)
{
for(int k=1;k<m;k++)
p=p->next;
q=p->next;
m=q->key;
cout<<"第"<<i<<"个出列的是"<<q->num<<"号"<<endl;
数据结构实验
题目:约瑟夫环
一、问题描述
用循环单链表实现约瑟夫环。
二、概要设计及存储表示
建立不带头结点的循环单链表,通过循环语句实现结点指针的传递及结点的删除,并输出删除的节点顺序。
每个结点分别存储一个序号及一个密钥两个变量,以及指向下一结点的指针。
三、调试分析
1.结点建立时发现错误,忘记结点应存储两个数据。
数据结构实验一约瑟夫(Joseph)问题
华北#########学院数据结构实验报告2011~2012学年第二学期级计算机专业班级:学号:姓名:实验一线性表及其应用一、实验题目:线性表及其应用——约瑟夫环二、实验内容:1.设带头结点的单链表ha和hb中结点数据域值按从小到大顺序排列,且各自链表内无重复的结点,要求:(1)建立两个按升序排列的单链表ha和hb。
(2)将单链表ha合并到单链表hb中,且归并后的hb链表内无重复的结点,结点值仍保持从小到大顺序排列。
(3)输出合并后单链表hb中每个结点的数据域值。
代码:实验结果:struct Node{ int data;Node* next; };typedef Node Slink;void create(Slink* h);void show(Slink* h);void merge(Slink* ha,Slink* hb);#include<iostream.h>void main(){cout<<"创建链表ha"<<endl;Slink ha; ha.next =NULL;create(&ha);cout<<"链表ha的节点排列"<<endl;show(&ha);cout<<endl;cout<<"创建链表hb"<<endl;Slink hb; hb.next =NULL;create(&hb);cout<<"链表hb的节点排列"<<endl;show(&hb);cout<<endl;cout<<"合并后链表hb的节点排列"<<endl;merge(&ha,&hb);show(&hb);}void create(Slink* h){if(!h) return;int n=0;//节点总数int j=0;//累计创建结点个数cout<<"请输入创建节点的个数"<<endl;cin>>n;Node* F=h;//F始终指向tou节点Node* pre=h;//pre始终指向要插入位置的前一个节点while(j<n){Node* p=new Node;cout<<"请输入节点的数据"<<endl;cin>>p->data;//链表为空时if(!F->next ){ F->next =p;p->next =NULL;j++;continue;}//链表不空时while(pre->next ){ if(p->data <pre->next ->data ){ p->next =pre->next ;pre->next =p;pre=h;j++;break;}else if (p->data ==pre->next ->data){ cout<<"该值已存在,请重新输入"<<endl;break;}pre=pre->next ;}if(!pre->next ){ pre->next =p;p->next =NULL;j++;}}}void merge(Slink* ha,Slink* hb){ //p遍历ha,q遍历hbNode * p=ha->next ;Node * q=hb->next ;//pw始终指向新生成链表的最后一个结点Node * pw=hb;while(p&&q){ if((p->data)<(q->data)){ pw->next=p;p=p->next;pw=pw->next;continue;}if((p->data)>(q->data)){ pw->next=q;q=q->next;pw=pw->next;continue;}if((p->data)==(q->data)){ pw->next=q;p=p->next;q=q->next;pw=pw->next;continue;}}while(p){ pw->next=p;p=p->next;pw=pw->next;}while(q){ pw->next=q;q=q->next;pw=pw->next;}pw->next=NULL;}void show(Slink* h){Node* p=h->next ;while(p ){ cout<<p->data <<" ";p=p->next ;}cout<<endl;}2.约瑟夫(Joseph)问题。
约瑟夫问题实验报告
一、实验目的1. 理解并掌握约瑟夫问题的基本原理和解决方法。
2. 学习使用循环链表解决线性问题。
3. 提高编程能力和算法设计能力。
二、实验原理约瑟夫问题(Josephus Problem)是一个著名的数学问题,也称为约瑟夫环问题。
问题描述为:N个人围成一圈,从第一个人开始按顺时针方向报数,每数到M的人出列,然后从下一个人开始继续报数,直到所有人都出列。
我们需要找到一种方法,计算出每个人出列的顺序。
三、实验内容1. 创建一个循环链表,模拟N个人围成一圈。
2. 编写一个函数,实现报数和出列操作。
3. 输出每个人出列的顺序。
四、实验步骤1. 定义一个循环链表节点结构体,包含编号和指向下一个节点的指针。
2. 创建一个循环链表,包含N个节点,节点的编号依次为1到N。
3. 编写一个函数`kill(int m, int n)`,实现报数和出列操作:- 初始化一个指针指向第一个节点。
- 从第一个节点开始,按照报数上限M进行报数,每数到M的人出列。
- 更新指针,指向下一个节点,继续报数。
- 重复上述步骤,直到所有节点都被删除。
4. 输出每个人出列的顺序。
五、实验代码```c#include <stdio.h>#include <stdlib.h>// 定义循环链表节点结构体typedef struct Node {int number; // 节点编号struct Node next; // 指向下一个节点的指针} Node;// 创建循环链表Node create(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 printList(Node head) {Node temp = head;do {printf("%d ", temp->number);temp = temp->next;} while (temp != head);printf("\n");}// 解决约瑟夫问题void josephus(int m, int n) {Node head = create(n);Node temp = head, pre = NULL;for (int i = 1; i <= n; i++) {for (int j = 1; j < m; j++) {pre = temp;temp = temp->next;}printf("%d ", temp->number);pre->next = temp->next; // 删除节点 free(temp);temp = pre->next;}printf("\n");}int main() {int m, n;printf("请输入报数上限M: ");scanf("%d", &m);printf("请输入人数N: ");scanf("%d", &n);printf("初始站队为: ");josephus(m, n);return 0;}```六、实验结果与分析通过运行实验代码,可以得到每个人出列的顺序。
约瑟夫问题实验报告
约瑟夫问题实验报告篇一:约瑟夫问题数据结构实验报告中南民族大学管理学院学生实验报告实验项目: 约瑟夫问题课程名称:数据结构年级:专业:信息管理与信息系统指导教师:实验地点:管理学院综合实验室完成日期:小组成员:学年度第一、实验目的(1)掌握线性表表示和实现;(2)学会定义抽象数据类型;(3)学会分析问题,设计适当的解决方案;二、实验内容【问题描述】:编号为1,2,…,n 的 n 个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数上限值 m,从第一个人开始按顺时针方向自 1 开始顺序报数,报到 m 时停止报数。
报 m 的人出列,将他的密码作为新的 m 值,从他在顺时针方向上的下一个人开始重新从 1 报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
【基本要求】:利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。
【测试数据】:m 的初值为 20;密码:3,1,7,2,4,8,4(正确的结果应为 6,1,4,7,2,3,5)。
三、实验步骤(一)需求分析对于这个程序来说,首先要确定构造链表时所用的插入方法。
当数到m时一个人就出列,也即删除这个节点,同时建立这个节点的前节点与后节点的联系。
由于是循环计数,所以才采用循环列表这个线性表方式。
程序存储结构利用单循环链表存储结构存储约瑟夫数据(即n个人的编码等),模拟约瑟夫的显示过程,按照出列的顺序显示个人的标号。
编号为 1,2,?,n 的 n 个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数上限值 m,从第一个人开始按顺时针方向自 1 开始顺序报数,报到 m 时停止报数。
报 m 的人出列,将他的密码作为新的 m 值,从他在顺时针方向上的下一个人开始重新从 1 报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
基本要求是利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。
约瑟夫问题数据结构实验报告
约瑟夫问题数据结构实验报告实验概述本实验旨在通过实现约瑟夫问题的求解算法,深入理解链表数据结构的应用,以及算法的时间复杂度分析。
实验将通过编写程序来模拟约瑟夫问题,并测试不同规模下的时间性能,从而验证算法的准确性和效率。
实验目的●理解约瑟夫问题的定义和求解算法●掌握链表数据结构的基本操作●理解算法的时间复杂度分析方法实验内容1·约瑟夫问题约瑟夫问题是一个经典的数学问题,描述如下:n个人围成一圈,从第一个人开始报数,报到m的人出圈,然后从出圈的下一个人重新开始报数,直到剩下最后一个人。
2·数据结构设计为了解决约瑟夫问题,我们可以使用循环链表来表示n个人围成的圈。
链表节点的数据域存储每个人的编号,指针域指向下一个人。
3·算法设计约瑟夫问题的求解算法如下:1·创建一个循环链表,并初始化n个人的编号。
2·从第一个人开始,依次报数m次,直到找到第m个人。
3·将第m个人从链表中删除。
4·重复步骤2和3,直到只剩下最后一个人。
4·程序实现下面是约瑟夫问题求解算法的主要实现步骤:1·定义一个循环链表的结构,并实现链表的初始化操作。
2·实现算法的主函数,用于接收输入参数n和m,并调用其他函数进行求解。
3·实现一个函数,用于模拟报数过程,并返回每次报数的人的编号。
4·实现一个函数,用于删除链表中指定位置的节点。
5·实现一个函数,用于遍历链表,输出剩下的最后一个人的编号。
实验结果及分析在实验中我们分别测试了5个人和10个人的情况,对比了不同m值下的运行时间,并绘制了相应的曲线图。
实验结果表明,约瑟夫问题的求解算法在不同规模下的时间复杂度为O(nm),其中n为人数,m为报数值。
随着m值的增大,算法的运行时间也呈指数级增长。
附件本文档所涉及的附件包括:●源代码文件●实验结果数据文件●曲线图文件法律名词及注释本文档没有涉及法律名词及注释。
数据结构实验报告约瑟夫环
数据结构实验报告约瑟夫环约瑟夫环是一个经典的问题,涉及到数据结构中的循环链表。
在本次数据结构实验中,我们将学习如何使用循环链表来解决约瑟夫环问题。
约瑟夫环问题最早出现在古代,传说中的犹太历史学家约瑟夫斯·弗拉维奥(Josephus Flavius)在围攻耶路撒冷时,为了避免被罗马人俘虏,与其他39名犹太人躲进一个洞穴中。
他们决定宁愿自杀,也不愿被敌人俘虏。
于是,他们排成一个圆圈,从第一个人开始,每次数到第七个人,就将他杀死。
最后剩下的人将获得自由。
在这个问题中,我们需要实现一个循环链表,其中每个节点表示一个人。
我们可以使用一个整数来表示每个人的编号。
首先,我们需要创建一个循环链表,并将所有人的编号依次添加到链表中。
接下来,我们需要使用一个循环来模拟每次数到第七个人的过程。
我们可以使用一个指针来指向当前节点,然后将指针移动到下一个节点,直到数到第七个人为止。
一旦数到第七个人,我们就将该节点从链表中删除,并记录下该节点的编号。
然后,我们继续从下一个节点开始数数,直到只剩下一个节点为止。
在实现这个算法时,我们可以使用一个循环链表的数据结构来表示约瑟夫环。
循环链表是一种特殊的链表,其中最后一个节点的指针指向第一个节点。
这样,我们就可以实现循环遍历链表的功能。
在实验中,我们可以使用C语言来实现循环链表和约瑟夫环算法。
首先,我们需要定义一个节点结构体,其中包含一个整数字段用于存储编号,以及一个指针字段用于指向下一个节点。
然后,我们可以实现创建链表、添加节点、删除节点等基本操作。
接下来,我们可以编写一个函数来实现约瑟夫环算法。
该函数接受两个参数,分别是参与游戏的人数和每次数到第几个人。
在函数内部,我们可以创建一个循环链表,并将所有人的编号添加到链表中。
然后,我们可以使用一个循环来模拟每次数到第几个人的过程,直到只剩下一个节点为止。
在每次数到第几个人时,我们可以删除该节点,并记录下其编号。
最后,我们可以返回最后剩下的节点的编号。
约瑟夫环实验报告
约瑟夫环实验报告约瑟夫环(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号人。
约瑟夫环问题 实验报告完整版
{
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)给定n和m,求出最后剩下的人的编号。
(2)给定n和m,按顺序输出出圈的人的编号。
⑵算法思路本实验将使用环形链表作为数据结构存储人员编号。
首先,创建一个含有n个节点的环形链表,每个节点表示一个人的编号。
然后,按照报数规则不断遍历链表,当报数等于m时,删除当前节点,并将游标指向下一个节点。
重复此过程,直到只剩下一个节点。
最后剩下的节点即为问题的解。
⒊算法设计⑴定义数据结构为了实现约瑟夫问题的求解,我们需要设计以下数据结构:(1)Person:表示每个人的节点,包含编号和指向下一个节点的指针。
(2)CircularLinkedList:表示环形链表,包含人员总数,当前游标位置和指向第一个节点的指针。
⑵算法实现(1)创建环形链表根据输入的人员总数n,创建一个含有n个节点的环形链表,每个节点表示一个人。
初始化时,节点的编号为从1到n,指向下一个节点的指针为空。
(2)解决约瑟夫问题通过循环遍历环形链表,按照报数规则逐个删除节点,直到只剩下一个节点为止。
具体步骤如下:①初始化报数计数器count=1,游标指向链表的第一个节点。
②从游标指向的节点开始,依次报数,每报数一次,count加1.③当count等于m时,删除当前节点,并将游标指向下一个节点。
④重复步骤②和③,直到只剩下一个节点。
(3)输出解决结果根据求解约瑟夫问题的要求,输出最后剩下的人的编号或按顺序输出出圈人的编号。
⒋性能分析本算法的时间复杂度为O(nm),其中n表示人员总数,m表示报数的步长。
数据结构实验报告一-约瑟夫环问题
实验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)抽象数据类型的定义:为实现上述程序的功能,可以用整数存储用户的输入。
并将用户输入的值存储于线性表中。
线性表ADT定义如下:ADT list数据对象:整形数据关系:线性关系,即<ai,ai+1>(0≤a<n)。
基本操作:bool remove(int &elem)//移除一个元素,被移除的元素赋给elem//如果操作成功,返回true,否则返回falsebool isEmpty()//判断数组的元素是否清空,空返回true,否则返回falsebool setPos(int place)//设置当前元素的位置,设置成功返回true,否则返回falseint getLength()//获取数组的实际长度(2)算法的基本思想:约瑟夫环问题中的数据是人所在的位置,而这种数据是存在“第一元素、最后元素”,并且存在“唯一的前驱和后继的”,符合线性表的特点。
数据结构实验报告—约瑟夫问题求解
数据结构实验报告—约瑟夫问题求解《计算机软件技术基础》实验报告I—数据结构实验⼀、约瑟夫斯问题求解⼀、问题描述1.实验题⽬:编号1,2,....,n的n个⼈顺时针围坐⼀圈,每⼈持有⼀个密码(正整数)。
开始选择⼀个正整数作为报数上限m,从第⼀个⼈开始顺时针⾃1报数,报到m的⼈出列,将他的密码作为新的m值,从他在顺时针⽅向下⼀个⼈开始重新从1报数,直⾄所有⼈全部出列。
2.基本要求:利⽤单向循环链表存储结构模拟此过程,按照出列的顺序印出个⼈的编号。
3.测试数据:n=7,7个⼈的密码依次为:3,1,7,2,4,8,4.m初值为6(正确的出列顺序应为6,1,4,77,2,3)。
⼆、需求分析1.本程序所能达到的基本可能:该程序基于循环链表来解决约瑟夫问题。
⽤循环链表来模拟n个⼈围坐⼀圈,⽤链表中的每⼀个结点代表⼀个⼈和他所代表的密码。
在输⼊初始密码后m,对该链表进⾏遍历,直到第m个结点,令该结点的密码值作为新的密码值,后删除该结点。
重复上述过程,直⾄所有的结点被释放空间出列。
2.输⼊输出形式及输⼊值范围:程序运⾏后提⽰⽤户输⼊总⼈数。
输⼊⼈数n后,程序显⽰提⽰信息,提⽰⽤户输⼊第i个⼈的密码,在输⼊达到预定次数后⾃动跳出该循环。
程序显⽰提⽰信息,提⽰⽤户输⼊初始密码,密码须为正整数且不⼤于总⼈数。
3.输出形式提⽰⽤户输⼊初始密码,程序执⾏结束后会输出相应的出列结点的顺序,亦即其编号。
⽤户输⼊完毕后,程序⾃动运⾏输出运⾏结果。
4.测试数据要求:测试数据n=7,7个⼈的密码依次为:3,1,7,2,4,8,4。
m初值为6(正确的出列顺序应为6,1,4,7,2,3,5)。
三、概要设计为了实现上述功能,应⽤循环链表来模拟该过程,⽤结构体来存放其相应的编号和密码信息,因此需要循环链表结构体这个抽象数据类型。
1.循环链表结构体抽象数据类型定义:ADT Node{数据对象:D={ai,bi,ci|ai∈int, bi∈int,ci∈(Node*),i =1,2...,n,n ≥0}:数据关系:R=?基本操作:CreatList(int n) //构建循环单链表;Order(int m,node *l) //输出函数,输出出列顺序并删除链表中的结点;}ADT node;2. ADT的C语⾔形式说明:typedef struct Node{int num; //结点的数据域,存放编号;int word; //结点的数据域,存放密码;struct Node *next; //结点的指针域,存放指向下⼀结点的指针;}Node;Node *CreatList( ) //建⽴循环单项链表;void Order(Node *h) //输出出列顺序并删除结点;3. 主程序流程及其模块调⽤关系:1).主程序流程:先提⽰⽤户输⼊相关数据:总⼈数,运⾏循环链表结构体模块,输⼊每个⼈持有的密码值,创建出新链表,运⾏输出函数模块,再输⼊初始密码m值,输出出列序列。
约瑟夫问题数据结构实验报告
约瑟夫问题数据结构实验报告[正文]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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
中南民族大学管理学院学生实验报告实验项目: 约瑟夫问题课程名称:数据结构年级:专业:信息管理与信息系统指导教师:实验地点:管理学院综合实验室完成日期:小组成员:2012 学年至2013 学年度第1 学期一、实验目的(1)掌握线性表表示和实现;(2)学会定义抽象数据类型;(3)学会分析问题,设计适当的解决方案;二、实验内容【问题描述】:编号为1,2,…,n的n 个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数上限值m,从第一个人开始按顺时针方向自 1 开始顺序报数,报到m 时停止报数。
报m 的人出列,将他的密码作为新的m 值,从他在顺时针方向上的下一个人开始重新从1 报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
【基本要求】:利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。
【测试数据】:m 的初值为20;密码:3,1,7,2,4,8,4(正确的结果应为6,1,4,7,2,3,5)。
三、实验步骤(一)需求分析对于这个程序来说,首先要确定构造链表时所用的插入方法。
当数到m 时一个人就出列,也即删除这个节点,同时建立这个节点的前节点与后节点的联系。
由于是循环计数,所以才采用循环列表这个线性表方式。
程序存储结构利用单循环链表存储结构存储约瑟夫数据(即n个人的编码等),模拟约瑟夫的显示过程,按照出列的顺序显示个人的标号。
编号为1,2,…,n 的 n 个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数上限值 m,从第一个人开始按顺时针方向自1 开始顺序报数,报到 m 时停止报数。
报 m 的人出列,将他的密码作为新的 m 值,从他在顺时针方向上的下一个人开始重新从 1 报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
基本要求是利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。
程序执行的命令(1)构造单向循环链表。
(2)按照出列的顺序引出各个人的标号。
测试数据 m 的初值为 20;密码:3,1,7,2,4,8,4(正确的结果应为 6,1,4,7,2,3,5)(1)、插入:在把元素插入到循环链表中时,由于是采用的头插法,所以我保留了front头结点。
在每加入一个节点时,都会直接连接在front后面,从而保证一开始就赋值的rear尾节点不用修改。
伪代码阐释如下:1)、在堆中建立新节点:Node<T> *s=new Node<T>;2)、将a[i]写入到新节点的数据域:s->data=a[i];3)、修改新节点的指针域:s->next=front->next;4)、修改头结点的指针域,将新节点加入到链表中:front->next=s;时间复杂度为:1;(2)、删除:首先通过p 指针查找到所要删除的节点的前一个节点,继而通过q=p->next 简单地删除掉。
假设所要查找的为第i 个元素。
伪代码阐释如下:1)、在堆中建立新节点p,通过循环查找到i-1,将此节点的地址赋给p 。
2)、设q 指向第i 个节点:若p=rear ,则q=front->next; 否则,q=p->next;3)、摘链,即将q 从链表中摘除:若q=rear ,则p->next=front->next ;否则,则p-next=q->next.4)、保存q 元素的数据:x=q->data ;5)、释放q 元素:delete q ;时间复杂度为:1;(3)、约瑟夫问题的基本思想:在这个循环查找问题中,通过循环链表实现了循环查找到节点。
一个关键部分就是删除节点后进行链表的链接,从而保证链表的循环性。
在查找方面上,我利用了一个for 循环来计数所查找过的节点。
其中查找的时间复杂度也为1;(二)概要设计测试主函数流程:流程图如下:否(三)详细设计#include<iostream> using namespace std; const int d=50000; struct Node{int data;struct Node*next; //声明next指针};class Clinklist{public:Clinklist(int a[],int n);void Josef(int m,int n);private:Node *rear; //声明rear和front指针Node *front;int n;};Clinklist::Clinklist(int a[],int n){rear=new Node;front=new Node;front->next=rear;//构造空单链表rear->next=front;rear->data=a[n-1];for(int i=n-2;i>=0;i--){Node*s=new Node; //循环插入元素来建立链表s->data=a[i];s->next=front->next;front->next=s;}}void Clinklist::Josef(int m,int n){Node* p=front;int j=0;while(front->next!=front){int i=0;while(i!=m-1) //实现第m-1个节点的查找{if(p==rear)p=front->next;else p=p->next;i++;}Node* q=p->next;if(p==rear) //排除p恰好为rear节点的情况{q=front->next;front->next=q->next;p->next=front->next;}else{if(q==rear) //排除q恰好为rear节点的情况p->next=front->next; //完成摘链elsep->next=q->next; //完成摘链}int x=q->data; //保留q点数据delete q; //完成q节点的删除j++;if(j==n)cout<<"所出的最后一个人的编号是:"<<x<<endl;}}int main(){int m,n;cout<<"请输入人数(1<=n<=50000):"<<endl;cin>>n;int member[d];for(int i=0;i<n;i++) //建立数组{member[i]=i+1;}cout<<"请输入要按那个数进行计算(m>=1):"<<endl;cin>>m;if(n<=0||m<=0)throw"所输入的数不符合要求!";Clinklist pro(member,n); //构造Clinklist类的对象pro.Josef(m,n);return 0;}(四)调试分析调试时出现的问题及解决的方法1、早期程序只写了约瑟夫的实现部分,没有对输入的数据进行筛选,测试时会出错。
2、在先前的程序循环过程中没有进行优化,导致循环次数过多,浪费了一定的时间。
3、为了限制在输入过程中不会上溢,只在输入中限定为四个不全为零的数字,但是做的是一个循环。
在约瑟夫的实现在程序中,为for循环,时间复杂度为o(m%n-1)当n=1时,复杂度为o(1)。
4、在调试时一开始用的是模板类,调试时就总会遇到“无法解析的外部指令”之类的问题。
由于无法解决,对模板类的理解不好,所以就去掉了模板类的应用。
Templete<T>还需要再次加强。
5、“rear指针找不到声明”,这个的解决方案是参照别的线性表例子,加上了如下struct类型的语句,才得以运行正常:struct Node{int data;struct Node*next;};6、这个是最严重的逻辑错误,就是编译的时候没有任何问题,在程序运行时会出现乱码或者出错的情况。
这个完全靠一点点的逻辑判断了,又用了最笨的方法:在纸上画一个循环链表才搞定。
(五)用户手册1、我们这个程序的运行环境为 VC++6.0操作系统,2、进入演示程序后即显示文本方式的用户界面:(六)测试结果(七)心得体会数据结构的课程设计,相对来说还是一个较大的工程,我们小组各个成员相互合作,虽然里面的内容不是很完备,但总体上还是一个比较能要体现数据结构的知识点能力的程序了,这个设计让我们在课堂中学到的理论知识,解决相应的实际问题,深入理解和灵活掌握所学的内容,使我们在实践的过程中收获匪浅,认真去做,踏踏实实,静静思考,慢慢进步,会有收获的。
(八)团队介绍小组成员基本情况介绍组长:雷灵花11056024组员:涂艺11056022伍雨豪11056029小组成员分工情况组长雷灵花,选择的实验设计为第一模块的约瑟夫问题,完成了第一个实验的程序设计和最终实验报告的总结。
组员涂艺,完成了第二个实验的程序设计和实验报告的撰写工作,选择的程序设计为第一模块的城市链表实验。
组员伍宇豪,在进行实验当中查阅了大量的相关资料,给出了实验的程序设计和源代码上的文件资料和指导。
小组成员任务完成情况程序一和程序二的调试工作完成情况良好,各个结果都能运行,组长实验一的程序和实验报告完成符合老师要求格式,组员涂艺程序和实验报告完成情况基本一致,组员伍宇豪也提供了很多的资料和技术支持。
总体来说,团队意识很好,一起共同完成学习任务。
(九)附录:源程序清单源程序文件名清单:#include<iostream>using namespace std;const int d=50000;struct Node{int data;struct Node*next; //声明next指针};class Clinklist{public:Clinklist(int a[],int n);void Josef(int m,int n);private:Node *rear; //声明rear和front指针Node *front;int n;};Clinklist::Clinklist(int a[],int n){rear=new Node;front=new Node;front->next=rear;//构造空单链表rear->next=front;rear->data=a[n-1];for(int i=n-2;i>=0;i--){Node*s=new Node; //循环插入元素来建立链表s->data=a[i];s->next=front->next;front->next=s;}}void Clinklist::Josef(int m,int n){Node* p=front;int j=0;while(front->next!=front){int i=0;while(i!=m-1) //实现第m-1个节点的查找{if(p==rear)p=front->next;else p=p->next;i++;}Node* q=p->next;if(p==rear) //排除p恰好为rear节点的情况{q=front->next;front->next=q->next;p->next=front->next;}else{if(q==rear) //排除q恰好为rear节点的情况p->next=front->next; //完成摘链elsep->next=q->next; //完成摘链}int x=q->data; //保留q点数据delete q; //完成q节点的删除j++;if(j==n)cout<<"所出的最后一个人的编号是:"<<x<<endl;}}int main(){int m,n;cout<<"请输入人数(1<=n<=50000):"<<endl;cin>>n;int member[d];for(int i=0;i<n;i++) //建立数组{member[i]=i+1;}cout<<"请输入要按那个数进行计算(m>=1):"<<endl;cin>>m;if(n<=0||m<=0)throw"所输入的数不符合要求!";Clinklist pro(member,n); //构造Clinklist类的对象pro.Josef(m,n);return 0;}指导教师批阅:指导教师:年月日。