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

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:约瑟夫环姓名:张光栋院系:计算机学院专业:网络工程年级: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个数输出到屏幕上三.详细设计首先,设计实现约瑟夫环问题的存储结构。
实验报告 约瑟夫问题

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;
}
实验中遇到的问题及解决方法
实验结果如下:
实验总结(结果和心得体会)
数据结构实验一 约瑟夫环问题实验报告电子版

for(i = 1;i<length;i++){
tmp = (Node *)malloc(sizeof(Node));
tmp->number = num[i];
tmp->pass = pas[i];
pri->next = tmp;
pri = tmp;
pri->next = head;
for(i=0;i<time;i++){ //找到要删除的结点
tmp = tmp->next;
}
printf("%d ",tmp->number);
timeห้องสมุดไป่ตู้= tmp->pass - 1;
deleteFromList(&head,tmp);//删除结点
tmp = tmp->next;//从下一个结点又开始计算
initList(head);
createFromTail(head,num,pas,sizeof(num)/sizeof(num[0]));
p = head;
printf("\n约瑟夫计数前,每个数和他的密码:\n");
for(i = 0;i<sizeof(num)/sizeof(num[0]);i++){
}
}
// 从链表中删除
void deleteFromList(List *head,Node *tmp)
{
Node *tmp1;
Node *tmp2;
tmp1 = *head;
tmp2 = tmp1;
//如果链表剩了一个元素
实验一约瑟夫问题实验报告

北京邮电大学电信工程学院数据结构实验报告实验名称:实验一——约瑟夫问题学生姓名: ***班级: 20132111**班内序号: **学号: 201321****日期: 2014年1月4日1.实验要求实验题目:利用循环链表实现约瑟夫问题的求解。
约瑟夫问题如下:已知n个人(n>=1)围坐一圆桌周围,从1开始顺序编号。
从序号为1的人开始报数,顺时针数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规则重复下去,直到所有人全部出列。
请问最后一个出列的人的编号。
实验目的:熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力2. 程序分析2.1 存储结构采用单循环链表实现约瑟夫问题的求解单循环链表示意图2.2关键算法分析1、关键算法首先通过尾插法建立单循环链表,若只有一个人,即只删除该人即可,若多于一人,—则每查到m个人时删除该节点,并将循环链表连接好,共循环n-1次,每次删除均返回被删数值。
2、代码详细分析:1).指针结构、类的声明struct Node //创立节点{int number;Node *next;};class Joseph //建立Joseph类{private:int n;int m;Node *front ; //front头指针public:Joseph(int nn, int mm); //构造函数~Joseph(); //析构函数void Delete(); //删除函数};2).单循环链表的建立Joseph::Joseph(int nn, int mm) //构造函数,建立循环链表{n=nn;m=mm;Node *p,*rear; //建立两个指针.尾插法,p2始终指向为节点for(int i=1; i<=n; i++){p=new Node;p->number=i;if(i==1) //建立空链表{front=p;rear=p;}else{rear->next=p;rear=p;}}rear->next=front; //尾指向头,循环完成}算法:—①设两个指针p,rear, rear为尾节点,p为新增加的节点②若是空链表,则front=p; rear=p;③否则用尾插法,即p 在rear的后面,将p给rear;rear->next=p; rear=p;④头结点赋给rear的指针域,完成循环循环次数为n, 时间复杂度为O(n)3). 输入值异常的情况cout<<"请输入环内总人数n:";cin>>n;if (n<1) //考虑n输入错误的情况{cout<<"n值输入错误"<<endl;}cout<<"请输入m值:";cin>>m;if (m<1) //考虑m输入异常的情况{cout<<"m值输入错误"<<endl;}4).寻找一定间隔的人,并将其删除void Joseph::Delete() //删除人员的函数{Node *p1,*p2,*p;int count; //用来计数p1=front; //头结点给p1if(m==1)cout<<"最后一个人的编号为"<<n<<endl;else{cout<<"每次被删除的人为"<<endl;for(int i=1; i<=n-1; i++) //共删除n-1个人,循环n-1次{count=1;while(count<m){p2=p1; //p2始终为编号为1的那个人p1=p1->next; //p1向后移count++;}cout<<p1->number<<"\t"; //输出被删除的编号p=p1;p2->next=p1->next;p1=p1->next; //p1后移,防止删除后指针悬挂delete p;—}cout<<endl;cout<<"最后一个人的编号为"<<p1->number<<endl;front=p1;} }…………③图1 删除结点示意图算法⑤设p1、p2均指向第一个节点;⑥查找第m个节点,p1=p1—>next; p2始终指向第一个节点⑦摘链,将p指向待删除的p1,即将p1元素从链表中摘除:⑧输出p1的数值⑨释放p元素:delete p;循环次数为m(n-1), 时间复杂度为O(n)5)析构函数Joseph::~Joseph() //析构函数{delete front;front=NULL;}6)主函数void main(){int n,m;cout<<"请输入总人数n=";cin>>n;cout<<"请输入间隔m=";cin>>m;Joseph joseph(n,m);joseph.Delete();}3. 程序运行结果测试主函数流程:开始等待用户输入输入值是否有效是查找删除节点循环次数是否大于n-1次是输出最后一个数值结束流程图示意图1、测试条件:n数量级无限制2、测试结论4. 总结由于是第一次做数据结构的实验,而上学期的C++也因长时间没有碰过而稍显手生,在码程序的过程中遇到了很多问题,但通过翻看教材已基本解决。
约瑟夫环数据结构实验报告

约瑟夫环数据结构实验报告约瑟夫环数据结构实验报告引言约瑟夫环是一种经典的数学问题,它涉及到一个有趣的数据结构。
本次实验旨在通过实现约瑟夫环数据结构,深入理解该问题,并探索其在实际应用中的潜力。
本报告将介绍实验的设计和实现过程,并分析实验结果。
实验设计在本次实验中,我们选择使用链表来实现约瑟夫环数据结构。
链表是一种非常灵活的数据结构,适合用于解决约瑟夫环问题。
我们设计了一个Josephus类,其中包含了创建环、添加元素、删除元素等操作。
实验实现1. 创建环在Josephus类中,我们首先需要创建一个循环链表。
我们使用一个头节点来表示环的起始位置。
在创建环的过程中,我们可以选择指定环的长度和起始位置。
2. 添加元素在创建环之后,我们可以通过添加元素来向约瑟夫环中插入数据。
我们可以选择在环的任意位置插入元素,并且可以动态地调整环的长度。
3. 删除元素根据约瑟夫环的规则,每次删除一个元素后,下一个元素将成为新的起始位置。
我们可以通过删除元素的操作来模拟约瑟夫环的运行过程。
在删除元素时,我们需要考虑环的长度和当前位置。
实验结果通过实验,我们得出了以下结论:1. 约瑟夫环数据结构可以有效地模拟约瑟夫环问题。
通过创建环、添加元素和删除元素的操作,我们可以模拟出约瑟夫环的运行过程,并得到最后剩下的元素。
2. 约瑟夫环数据结构具有一定的应用潜力。
除了解决约瑟夫环问题,该数据结构还可以用于其他类似的问题,如任务调度、进程管理等。
3. 约瑟夫环数据结构的时间复杂度较低。
由于约瑟夫环的特殊性质,我们可以通过简单的链表操作来实现该数据结构,使得其时间复杂度较低。
结论本次实验通过实现约瑟夫环数据结构,深入理解了该问题,并探索了其在实际应用中的潜力。
通过创建环、添加元素和删除元素的操作,我们可以模拟出约瑟夫环的运行过程,并得到最后剩下的元素。
约瑟夫环数据结构具有一定的应用潜力,并且具有较低的时间复杂度。
通过本次实验,我们对数据结构的设计和实现有了更深入的理解,并为将来的研究和应用奠定了基础。
约瑟夫环课程设计实验报告
《数据结构》课程设计报告课程名称: 《数据结构》课程设计课程设计题目: 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个人,编号从1到n,围成一个圈。
按照一定的规则,从第一个人开始报数,每次报到m的人将被淘汰。
然后,从下一个人开始重新报数,如此循环,直到只剩下一个人为止。
这个问题的解决方法有很多,其中最常见的是使用链表数据结构。
我们可以将每个人表示为一个节点,节点之间通过指针连接,形成一个环形链表。
每次淘汰一个人后,只需要将指针跳过被淘汰的节点,重新连接链表。
为了更好地理解这个问题,我们可以通过一个简单的例子来演示。
假设有10个人,编号从1到10,每次报数到3的人将被淘汰。
首先,我们将这10个人表示为一个环形链表:1->2->3->4->5->6->7->8->9->10->1。
按照规则,第一次报数到3的人是3号,所以我们将3号节点从链表中删除:1->2->4->5->6->7->8->9->10->1。
接下来,从4号节点开始重新报数。
第二次报数到3的人是6号,所以我们再次将6号节点从链表中删除:1->2->4->5->7->8->9->10->1。
以此类推,直到只剩下一个人为止。
通过这个例子,我们可以看到约瑟夫环问题的解决方法非常简单直观。
使用链表数据结构,每次淘汰一个人后,只需要将指针跳过被淘汰的节点,重新连接链表。
这种方法的时间复杂度为O(n*m),其中n为人数,m为报数的次数。
除了链表,还有其他数据结构可以用来解决约瑟夫环问题。
数据结构实验报告约瑟夫环
数据结构实验报告约瑟夫环约瑟夫环是一个经典的问题,涉及到数据结构中的循环链表。
在本次数据结构实验中,我们将学习如何使用循环链表来解决约瑟夫环问题。
约瑟夫环问题最早出现在古代,传说中的犹太历史学家约瑟夫斯·弗拉维奥(Josephus Flavius)在围攻耶路撒冷时,为了避免被罗马人俘虏,与其他39名犹太人躲进一个洞穴中。
他们决定宁愿自杀,也不愿被敌人俘虏。
于是,他们排成一个圆圈,从第一个人开始,每次数到第七个人,就将他杀死。
最后剩下的人将获得自由。
在这个问题中,我们需要实现一个循环链表,其中每个节点表示一个人。
我们可以使用一个整数来表示每个人的编号。
首先,我们需要创建一个循环链表,并将所有人的编号依次添加到链表中。
接下来,我们需要使用一个循环来模拟每次数到第七个人的过程。
我们可以使用一个指针来指向当前节点,然后将指针移动到下一个节点,直到数到第七个人为止。
一旦数到第七个人,我们就将该节点从链表中删除,并记录下该节点的编号。
然后,我们继续从下一个节点开始数数,直到只剩下一个节点为止。
在实现这个算法时,我们可以使用一个循环链表的数据结构来表示约瑟夫环。
循环链表是一种特殊的链表,其中最后一个节点的指针指向第一个节点。
这样,我们就可以实现循环遍历链表的功能。
在实验中,我们可以使用C语言来实现循环链表和约瑟夫环算法。
首先,我们需要定义一个节点结构体,其中包含一个整数字段用于存储编号,以及一个指针字段用于指向下一个节点。
然后,我们可以实现创建链表、添加节点、删除节点等基本操作。
接下来,我们可以编写一个函数来实现约瑟夫环算法。
该函数接受两个参数,分别是参与游戏的人数和每次数到第几个人。
在函数内部,我们可以创建一个循环链表,并将所有人的编号添加到链表中。
然后,我们可以使用一个循环来模拟每次数到第几个人的过程,直到只剩下一个节点为止。
在每次数到第几个人时,我们可以删除该节点,并记录下其编号。
最后,我们可以返回最后剩下的节点的编号。
Josephus problem
数据结构上机报告----Josephus Problem目录一、需求分析 (2)1.问题描述 (2)2.输入及输出格式 (2)a)输入格式 (2)b)输出格式 (3)c)输入及输出样例 (3)二、概要设计: (3)三、详细设计: (3)四、调试分析 (6)1.调试中所遇到的主要问题以及解决方法 (6)2.算法设计中的技巧和心得 (7)3.算法的时空复杂度分析 (7)4.算法设计的健壮性,可维护性,可扩展性分析 (7)五、用户手册: (7)六、测试数据(输入、输出文件) (8)1一、需求分析1.问题描述The Joseph's problem is notoriously known. For those who are not familiar with the original problem: from among n people, numbered 1, 2, . . ., n, standing in circle every m-th is going to be executed and only the life of the last remaining person will be saved. Joseph was smart enough to choose the position of the last remaining person, thus saving his life to give us the message about the incident. For example when n = 6 and m = 5 then the people will be executed in the order 5, 4, 6, 2, 3 and 1 will be saved.Suppose that there are k good guys and k bad guys (n = 2*k). In the circle the first k are good guys and the last k bad guys. You have to determine such minimal m that all the bad guys will be executed before the first good guy.2.输入及输出格式a)输入格式The input file consists of separate lines containing k. The last line in the input file contains 0. You can suppose that 0 < k < 8.用户只需要按照操作提示输入好人(坏人)的个数即可。
- 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;}指导教师批阅:指导教师:年月日。