约瑟夫环代码C++版

合集下载

约瑟夫环问题代码

/*约瑟夫环问题：设编号为1，2，3，……，n的n(n>0)个人按顺时针方向围坐一圈，每个人持有一个正整数密码。

开始时任选一个正整数做为报数上限m，从第一个人开始顺时针方向自1起顺序报数，报到m是停止报数，报m的人出列，将他的密码作为新的m值，从他的下一个人开始重新从1报数。

如此下去，直到所有人全部出列为止。

令n最大值取30。

要求设计一个程序模拟此过程，求出出列编号序列。

*/#include<stdio.h>#include<stdlib.h>typedef struct Joseph//结点类型定义{int index;int data;struct Joseph *next;}Joseph,*JosephList;void init_JosephList(JosephList &l)//对单链表进行初始化{l=(JosephList )malloc(sizeof(Joseph));l->next=NULL;}void CreateFromTail(JosephList L,int n){JosephList r,s;int c;int i;r=L;for(i=1;i<=n;i++){printf("第%d个人的密码：\n",i);s=(Joseph*)malloc(sizeof(Joseph));s->index=i;scanf("%d",&c);s->data=c;r->next=s;r=s;}r->next=L->next;}void Joseph(JosephList &L,int n,int m){JosephList p,q;p=L;while(n){if(m==1) m=n+1;for(int i=1;i<m;i++){p=p->next;}q=p->next;m=q->data;p->next=q->next;n--;printf("出列的人是第%d个人，密码是：%d\n",q->index,m);delete q;}}int main(){JosephList l;JosephList p;int n,m,i;init_JosephList(l);printf("请输入参加约瑟夫环的人数：");scanf("%d",&n);printf("请输入初始密码：");scanf("%d",&m);printf("请按尾插法建立约瑟夫环，请输入链表数据：\n");CreateFromTail(l,n);p=l->next;printf("约瑟夫环的人数及对应的密码为：\n");for(i=1;i<=n;i++){printf("第%d个人的密码为：%d\n",p->index,p->data);p=p->next;}printf("\n");Joseph(l,n,m);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.调试分析在本次试验调试中很不顺利。

c语言经典例题古老问题的解决

c语言经典例题古老问题的解决以下是一个经典的C语言例题，它是关于解决一个古老的问题：约瑟夫环问题。

约瑟夫环问题是一个著名的数学和计算机科学问题，其描述如下：有n个人围成一圈，从第k个人开始报数，数到m的人出圈，然后从下一个人开始重新报数，数到m的人再出圈，直到剩下最后一个人。

求最后留下的人在原序列中的编号。

以下是一个使用C语言解决这个问题的示例代码：```cinclude <>include <>int main() {int n, k, m;printf("请输入人数n：");scanf("%d", &n);printf("请输入开始报数的位置k：");scanf("%d", &k);printf("请输入数到m的人出圈的数m：");scanf("%d", &m);int a = (int )malloc(n sizeof(int));for (int i = 0; i < n; i++) {a[i] = i + 1;}int index = k - 1; // 初始位置为第k个人while (n > 1) {for (int i = 0; i < n; i++) {index = (index + m - 1) % n; // 计算下一个要出圈的人的位置printf("出圈的人是：%d\n", a[index]);free(a[index]); // 释放该位置的内存n--; // 人数减1}if (index >= k) { // 如果最后一个出圈的人的位置大于等于k，则交换位置，保证下次从第k个人开始报数int temp = a[index];a[index] = a[0];a[0] = temp;}index = (index + 1) % n; // 重新开始报数}printf("最后留下的人是：%d\n", a[0]); // 最后留下的人即为所求结果 free(a); // 释放整个数组的内存return 0;}```该程序首先要求用户输入人数n、开始报数的位置k和数到m的人出圈的数m，然后创建一个长度为n的数组a，将数组中的元素初始化为1到n 的整数。

约瑟夫环问题

约瑟夫环问题源代码：#include<stdio.h>#include<stdlib.h>typedef int ElemType;typedef struct LNode{int number;ElemType code;struct LNode *next;}LNode, *LinkList;void CreatList(LinkList L,int n){LinkList R = L,S;//R用于存放循环链表尾结点的位置ElemType c;printf("请输入第1个人的密码:\n");//建立首元结点scanf("%d",&c);L->number = 1;L->code = c;for(int i = 2;i <= n;i++){printf("请输入第%d个人的密码:\n",i);scanf("%d",&c);S = (LinkList)malloc(sizeof(LNode));S->number = i;S->code = c;R->next = S;R = S;//利用尾插法构造链表}R->next = L;//尾结点的指针指向首元结点建立循环链表}//建立链表（输入密码）int main(){int m, n;LinkList L, p, q;L = (LinkList)malloc(sizeof(LNode));printf("请输入人数n:\n");scanf("%d",&n);printf("请输入报数上限值m:\n");scanf("%d",&m);CreatList(L,n);p = L;while(p->next!=p){//当链表长度大于1时for(int i = 1;i < m;i++){q = p;//q为p的前驱结点p = p->next;}//找到报数m的结点m = p->code;printf("编号为%d的人出列。

约瑟夫环问题源代码(C语言)

约瑟夫环问题如下：已知n个人(n>=1)围桌一园桌周围，从1开始顺序编号。

从序号为1的人开始报数，顺时针数到m的那个人出列。

他的下一个人又从1开始报数，数到m的那个人又出列。

依此规则重复下去，直到所有人全部出列。

求解最后一个出列的人的编号。

本次实验是以顺序表求解约瑟夫环问题，程序流程图及程序运行结果如下：输入人数、所报数、第一个报数人编号存储并建立一个约瑟夫环通过循环结构依次查找每次出列的人的编号并输出输出最后一个出列的人的编号程序代码如下：#include<iostream>#include<process.h>#include<stdlib.h>using namespace std;struct Node //循环节点的定义{int number; //编号Node *next;};Node *CreateList(Node *L,int &n,int &m); //建立约瑟夫环函数void Joseph(Node *L,int n,int m); //输出每次出列号数函数Node *DeleteList(Node **L,int i,Node *q); //寻找每次出列人的号数int LengthList(Node *L); //计算环上所有人数函数void main() //主函数{system("color 75"); //设置颜色以美观Node *L;L=NULL; //初始化尾指针int n, m;cout<<"请输入人数N：";cin>>n; //环的长度if(n<1){cout<<"请输入正整数!";} //人数异常处理else{cout<<"请输入所报数M：";cin>>m;if(m<1){cout<<"请输入正整数!";} //号数异常处理else{L=CreateList(L,n,m); //重新给尾指针赋值Joseph(L,n,m);}}system("pause");}Node *CreateList(Node *L,int &n,int &m) //建立一个约瑟夫环（尾插法）{Node *q;for(int i=1;i<=n;i++){Node *p;p=new Node;p->number=i;p->next=NULL;if(i==1) L=q=p; //工作指针的初始化 else{q->next=p;q=q->next;}}q->next=L;if(L!=NULL){return(L);} //返回尾指针else cout<<"尾指针异常!"<<endl; //尾指针异常处理}void Joseph(Node *L,int n,int m) //输出每次出列的人{int k;cout<<"请输入第一个报数人：";cin>>k;if(k<1||k>n){cout<<"请输入1-"<<n<<"之间的数"<<endl;}else{cout<<"\n出列顺序:\n";for(int i=1;i<n;i++){Node *q = new Node;if(i==1) q=DeleteList(&L,k+m-1,q); //第一个出列人的号数else q=DeleteList(&L,m,q);cout<<"号数："<<q->number<<endl;delete q; //释放出列人的存储空间}cout<<"最后一个出列号数是："<<L->number<<endl; //输出最后出列人的号数}}Node *DeleteList(Node **L,int i,Node *q) //寻找每次出列的人{if(i==1) i+=LengthList(*L); //顺序依次出列情况的处理方式Node *p;p=*L;int j=0;while(j<i-2) {p=p->next;j++;}q = p->next;p->next=p->next->next;*L = p->next;return(q);}int LengthList(Node *L) //计算环上的人数{if(L){cout<<"尾指针错误!"<<endl;} //异常处理else{int i=1;Node *p=L->next;while(p!=L){i++;p=p->next;}return(i);}}实验体会：通过对本问题的分析，我进一步熟悉了对各种逻辑表达式的判断和指针的使用。

约瑟夫环的解决方法小汇总

约瑟夫环的解决方法用静态存储结构求解约瑟夫环问题静态存储结构，那就用数组。

本题的一个完整的c程序如下,程序在win-tc和Dev-c++下都调试通过。

# include <stdlib.h># include <stdio.h># define nmax 255main(){int i,j,k,m,n,num[nmax],*p;printf("\nInput number n and m:\n"); /* 这里输入总人数n和报数到几即退出的数m,手动输入*/scanf("%d%d",&n,&m);p=num;for(i=0;i<n;i++)*(p+i)=i+1; /* 人的位置编号从1开始到n */i=0; /* i为扫描一遍计数器，初值置为0，最大值为n，计到n归0再次重计*/k=0; /* k是计m计数器，记满m个归0重计*/j=0; /* j表示从圈子中退出的总人数*/while(j<n-1) /* 当退出的人数为n-1时结束循环，最后的那个没退出的就是所求*/{if(*(p+i)!=0) /* 从第一个值不为0的人开始计数*/k++;if(k==m){*(p+i)=0; /* 每记满m个将第m个人的值置0，表示该人退出圈子*/k=0; /* k记满m个归0重计*/j++; /* 退出圈子人数加1 */}i++; /* 一遍循环计数器加1，指向下一个人*/if(i==n) /* 如果一遍计数完成*/i=0; /* 归0从数组开始重新循环,跳过值为0的那些位置为m的倍数的编号*/}while(*p==0) /* 跳过值为0的位置编号,使p指向值不为零即最后留在圈子中的人*/p++;printf("The last one is NO.%d.\n",*p);getch();}上文来自百度知道。

约瑟夫环源代码

#include"stdio.h"#include"stdlib.h"#include"malloc.h"#include"conio.h"#define ERROR 1#define OK 0typedef int ElemType;typedef int Status;typedef struct LNode{ElemType code;ElemType number;struct LNode *next;}LNode,*LinkList;Status CreateLink_L(LinkList &L,int n){struct LNode *p,*q;int i;if(n<=0)return ERROR;printf("请输入个人的密码：");L = (LinkList)malloc(sizeof(LNode));L -> next = NULL;L -> number=1;scanf("%d",&L->code);p=L;q=L;for(i = 2;i <= n;++i){L = (LinkList)malloc(sizeof (LNode));L -> next = NULL;L -> number = i;scanf("%d",&L->code);q-> next=L;q = L;}L->next=p;//首尾链接,L指向最后一个人return OK;Status ListDelete_L(LinkList &L,int n,int k,ElemType &code,ElemType &number) {int i;LinkList p=NULL;if(L->next==L) //{p=L;L=NULL;}else{k=(k-1+n)%n;//该移动的次数for(i=1;i<=k;i++) L=L->next;//点到出列的前一个人p=L->next;//该出列的人L->next=p->next;}code=p->code;number=p->number;free(p);return OK;}Status Josephus_L(LinkList &L,int n){ElemType code=0;ElemType number=0;int m;if(L==NULL)return ERROR;printf("请输入m的初值：");scanf("%d",&m);printf("先后出列的人是：");while(L!=NULL){ListDelete_L(L,n--,m,code,number);m=code;printf("%d ",number);}printf("\n");return OK;}int main()LinkList L=NULL;int n;int m;printf("请输入人数：");while(!scanf("%d",&n)||n<=0){printf("请输入一个正整数：");fflush(stdin);}if(!CreateLink_L(L,n)) // 判断链表是否创建成功Josephus_L(L,n);elseprintf("创建链表失败");printf("按任意键结束程序");getch();return 0;}。

约瑟夫环c语言代码原创

head2=creat2(head1);
p=head2;
while(p!=NULL)
{
printf("%d ",p->num);
p=p->next;
}
}
printf("输入初始m值\n");
scanf("%d",&m);
p1=p2=(struct outlist *)malloc(sizeof(struct outlist));
head1=p1;
p0=head;temp=NULL;
while(p0->next!=p0)
{
i=1;
while(i<m)
};
struct peolist *creat1()
{
int i=1;
struct peolist *head;
struct peolist *p1,*p2;
printf("依次输入个人的密码,输入非正数时结束\n");
p1=p2=(struct peolist *)malloc(sizeof(struct peolist));
scanf("%d",&p1->secret);
head=p1;
p1->n=i;
while(p1->secret>0)
{
i++;
p2=p1;
p1=(struct peolist *)malloc(sizeof(struct peolist));
scanf("%dቤተ መጻሕፍቲ ባይዱ,&p1->secret);
p1->n=i;

C++约瑟夫环的实例代码

C++约瑟夫环的实例代码C++ 约瑟夫环的实例代码约瑟夫环是⼀个数学的应⽤问题：已知n个⼈（以编号1，2，3...n分别表⽰）围坐在⼀张圆桌周围。

从编号为k的⼈开始报数，数到m的那个⼈出列；他的下⼀个⼈⼜从1开始报数，数到m的那个⼈⼜出列；依此规律重复下去，直到圆桌周围的⼈全部出列。

分析：有n个⼈，要想所有的⼈都退出去，只有每个⼈喊到m，才可以退完，所以可以算出，n*m为所有⼈总共报数的总次数。

代码：/** 约瑟夫出圈*/#include <stdio.h>int main(){char peo[100] ;char *p_peo = peo;int i , n , skip , flag[100] = {0} , cnt;int *p_flag = NULL;printf("请输⼊⼈数：");scanf("%d", &n);printf("所有⼈如下：\n");for(p_peo , i = 0 ; p_peo < peo + n ; ++p_peo , ++i){*p_peo = 'a' + i;printf("%c ", *p_peo);}printf("\n");printf("请输⼊报数值：");scanf("%d", &skip);cnt = 0;while(cnt <= n * skip){for(p_peo = peo , p_flag = flag ; p_peo < peo + n ; ++p_peo , ++p_flag){if(*p_flag)continue;cnt++;if(!(cnt % skip)){*p_flag = 1;printf("%c ", *p_peo);}}}printf("\n");return 0;}如有疑问请留⾔或者到本站社区交流讨论，感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

约瑟夫环C 代码及实验报告

{
outArray[k]=listArray[j];// 将该元素放置到出列数组
里，并输出
cout<<outArray[k]<<" ";
k++;
listArray[j]=0; //将出列元素置 0
i=1; //下一个元素从 1 开始重新报数
}
else
i++; //报数编号与出列编号不同时，继续报数
if(a[i]==1) {
j=j+a[i]; if(j==m) {
j=0; a[i]=0; k++; cout<<i<<" "; }
} if(i==n)
i=0; }
}
七、实验心得李孟琪：该实验利用数组实现线性表，算法简便，但产生很多不必要的消耗，下一步可以尝试采用单链表，双链表实现该问题。李春阳：通过利用链表编写约瑟夫环，进一步掌握了约瑟夫环的原理，加深了对链表使用的理解雷鹤：这次实验遇到的最大问题是拘泥于基本要求中的利用数组来实现线性表，并用线性表来实现约瑟夫环问题，在尝试用链表实现后问题变得简单了些；在插入元素这一步费不少时间，头尾节点的移动关系也需要理解
四、详细设计
程序代码：
#include <iostream>
using namespace std;
main()
{
int n,m,k,j;
//n 为总人数，m 为出列编号
cin>>n>>m;
int *listArray=new int[n]; //将 n 个人放在大小为 n 的数组中

C语言用数组解决约瑟夫环问题

C语言用数组解决约瑟夫环问题C语言用数组解决约瑟夫环问题问题说明：在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，大家决定宁愿自杀也不要被敌人抓到，于是确定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。

然而约瑟夫和他的朋友并不想死去，那么他应该怎样安排他和他的朋友的位置，才能逃脱这场死亡游戏呢?有N个编号为1~N的`人围成一圈，现在每隔两个人(比如：1、4 之间隔了2、3)就将一个人淘汰出去，问最后剩下的是编号为几的人?算法代码如下：#include#includeint main(void){int people_count = 0;int *peoples = NULL;printf("please input people number: ");scanf("%d", &people_count);if (people_count < 2){printf("can't do Joseph\n");}peoples = (int *)calloc(people_count, sizeof(int));int i;for(i = 0; i < people_count; i++){peoples[i] = i+1;}i = 0;int j = 0;int rest = people_count;while(rest){if (i >= people_count){i %= people_count;}if (peoples[i] == 0){i++;continue;}if (j++ % 3 ==0 && rest > 1){printf("kill people NO. %d\n", peoples[i]); peoples[i] = 0;rest--;}else if (rest==1){printf("NO. %d is alive\n", peoples[i]); rest--;}i++;}system("pause");return 0;}。

约瑟夫环c 源代码讲解

#include <iostream> using namespace std; #define max 100 class node // 结点定义{public: int data; int secret_num; node *next; }; class Linklist //线性表定义 {public: Linklist(); ~Linklist(); node *head; node *pcurrent; void insert(int x,inta,Linklist&team); void Deletecurrent(Linklist&team); }; Linklist::~Linklist() {cout<<"欢迎再玩"; } Linklist::Linklist() //构造函数定义 {head=NULL; } voidLinklist::insert(int x,int a,Linklist&team) //线性表输入函数定义 {if (head==NULL) { node *newnode=new node; newnode->data=x; newnode->secret_num=a;pcurrent=head=newnode; } else {node *newnode=new node; newnode->data=x; newnode->secret_num=a; pcurrent->next=newnode; pcurrent=newnode; pcurrent->next=head; } } void Linklist::Deletecurrent(Linklist&team) //线性表删除函数定义，删除当前（pcurrent）结点 { node *p=pcurrent; while(p->next!=pcurrent)p=p->next; p->next=pcurrent->next; delete pcurrent; pcurrent=p->next; } int main() {intn,m,secret[max]; cout<<"请输入玩游戏人数："; cin>>n; cout<<"请输入第一个人开始报数的数字："; cin>>m; cout<<"请输入每个人的密码，并用空格隔开，输入完成后按下回车键"; int i,j; for(i=0;i<n;i++) cin>>secret[i]; Linklist team;for(i=0;i<n;i++) team.insert(i,secret[i],team); cout<<"出列的顺序是:"<<endl; if(n==1) //玩游戏人数只有一人 { cout<<team.head->data+1<<endl; return 0; } node*h=team.head; for(i=0;i<(m-1);i++) { h=h->next; team.pcurrent=h; } if(m==1) //当m=1时 {cout<<team.head->data+1<<endl; m=team.head->secret_num;team.pcurrent=team.head; team.Deletecurrent(team); } else { cout<<team.pcurrent->data+1<<endl; m=team.pcurrent->secret_num; team.Deletecurrent(team); }for(i=0;i<n-1;i++) //第一个人出列后，取他的密码继续进行 {if(m==1){cout<<team.pcurrent->data+1<<endl; m=team.pcurrent->secret_num;team.Deletecurrent(team); } else {int t; for(t=0;t<(m-1);t++)team.pcurrent=team.pcurrent->next; cout<<team.pcurrent->data+1<<endl;m=team.pcurrent->secret_num; team.Deletecurrent(team); } } return 0; }。

约瑟夫环c语言代码指针函数,JavaScript使用指针操作实现约瑟夫问题实例

约瑟夫环c语⾔代码指针函数,JavaScript使⽤指针操作实现约瑟夫问题实例本⽂实例讲述了JavaScript使⽤指针操作实现约瑟夫问题的⽅法。

分享给⼤家供⼤家参考。

具体分析如下：实现之前当然要⾃⼰来编写⼀些 JS 数组内部指针的操作函数，就像：reset(), current(), next(), prev(), search(), end() 这些函数，我们都要来⾃⼰实现，因为 JS 没有内置这些神奇的操作函数Array.prototype.pointer = 0;//模拟数组内部指针//Reset 函数，将数组内部指针归位(指向第⼀个元素)var reset = function(arrayObj){if(!(arrayObj instanceof Array)){alert("Reset() 函数参数类型错误！请检查输⼊！");return;}arrayObj.pointer = 0;}//Current 函数，返回数组内部指针指向的当前元素var current = function(arrayObj){if(!(arrayObj instanceof Array)){alert("Current() 函数参数类型错误！请检查输⼊！");return;}return arrayObj[arrayObj.pointer];}//End 函数，将数组内部指针指向最后⼀个元素var end = function(arrayObj){if(!(arrayObj instanceof Array)){alert("End() 函数参数类型错误！请检查输⼊！");return;}arrayObj.pointer = arrayObj.length - 1;return arrayObj[arrayObj.pointer];}//Next 函数，将数组内部指针下移⼀位//如果已经指向最后⼀个元素则返回 FALSEvar next = function(arrayObj){if(!(arrayObj instanceof Array)){alert("Next() 函数参数类型错误！请检查输⼊！"); return;}arrayObj.pointer ++;if(typeof arrayObj[arrayObj.pointer] == 'undefined'){ arrayObj.pointer --;return false;}return true;}//Prev 函数，将数组内部指针上移⼀位//如果已经指向第⼀个元素则返回 FALSEvar prev = function(arrayObj){if(!(arrayObj instanceof Array)){alert("Prev() 函数参数类型错误！请检查输⼊！"); return;}arrayObj.pointer --;if(typeof arrayObj[arrayObj.pointer] == 'undefined'){ arrayObj.pointer ++;return false;}return arrayObj[arrayObj.pointer];}//Unset 函数，删除指定的数组元素var unset = function(index, arrayObj){if(!(arrayObj instanceof Array)){alert("Unset() 函数参数类型错误！请检查输⼊！"); return;}if(typeof arrayObj[index] == 'undefined'){alert("Unset() 函数参数 index 错误！不存在此元素！"); return false;}arrayObj.splice(index, 1);return true;}//Search 函数，通过数组键值返回数组的键名var search = function(value, arrayObj){if(!(arrayObj instanceof Array)){alert("Search() 函数参数类型错误！请检查输⼊！");return;}for(index in arrayObj){if(arrayObj[index] == value){return index;}}return false;}//getKingMonkey 函数，我们的约瑟夫主函数，n 只猴⼦，数到 m function getKingMonkey(n, m){a = new Array();for(i = 1; i <= n; i ++){a[i] = i;}a[0] = 0;unset(0, a);reset(a);while(a.length > 1){for(counter = 1; counter <= m; counter ++){if(next(a)){if(counter == m){unset(search(prev(a), a), a);}}else{reset(a);if(counter == m){unset(search(end(a), a), a);reset(a);}}}}return current(a);}alert("猴⼦⼤王的编号为：" + getKingMonkey(100, 17));希望本⽂所述对⼤家的javascript程序设计有所帮助。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实习报告
题目：约瑟夫环
班级：031014 姓名：刘嵩学号：03101409 完成日期：2011.11.16
一、需求分析
1.本演示程序中，要求用户输入人数n和初始报数上限的值m。

并依次输入n个人
的密码（password）。

程序输出n个人的出列顺序。

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

3.程序执行的命令包括
1）构造链表2）依照题意对链表进行操作，每次删除一个链表的节点并将删
除节点的编号输出3）结束
4. 测试数据
Sample input
7 20
3 1 7 2
4 8 4
Sample output
6 1 4
7 2 3 5
二、概要设计（算法描述）
为实现上述程序功能，应以循环列表表示n个人围坐一圈。

循环列表每个节点所要包含的信息包括：1.每个人的编号 2.每个人的密码 3.指向下一个节点的指针。

建好链表后，从链表的首个节点开始，顺着链表向后移m次，得到一个节点Node。

输出Node的编号，并将Node从链表中删除，然后讲Node的密码值作为新的m。

重复以上步骤，直到所有节点均被从链表中删除为止。

算法复杂度为O(m*n)。

三、详细设计
代码如下:
#include<iostream>
using namespace std;
struct node
{
int id;
int password;
node* next;
};
int main()
{
i nt m,n;
c out<<"Enter the number of people:";
c in>>n;
c out<<"Enter the value of 'm':";
c in>>m;
n ode* p=new node [n+1];
c out<<"Enter the "<<n<<" people's password:"<<endl;
i nt i;
f or(i=0;i<n;i++){cin>>p[i].password;p[i].id=i+1;}
f or(i=0;i<n-1;i++)p[i].next=&p[i+1];
p[n-1].next=&p[0];
n ode* temp=&p[0];
n ode* last=&p[n-1];
w hile(n)
{
for(i=0;i<m-1;i++)
{
if(i==m-2)last=temp;
temp=temp->next;
}
last->next=temp->next;
cout<<temp->id<<" ";
n--;
m=temp->password+1;
}
c out<<endl;
d elet
e [] p;
r eturn 0;
}
四、调试分析
1、刚开始时last指针没有赋初值，会造成应对一些数据时无法输出结果。

五、用户手册
根据提示输入数据即可
六、测试结果
Enter the number of people:7
Enter the value of 'm':20
Enter the 7 people's password:
3 1 7 2
4 8 4
6 1 4
7 2 3 5
Process returned 0 (0x0) execution time : 19.437 s Press any key to continue.。