兰州大学管理学院约瑟夫环面向对象的程序代码

合集下载

C语言用循环单链表实现约瑟夫环

C语⾔⽤循环单链表实现约瑟夫环⽤循环单链表实现约瑟夫环（c语⾔），供⼤家参考，具体内容如下源代码如下，采⽤Dev编译通过，成功运⾏，默认数到三出局。

主函数：main.c⽂件#include <stdio.h>#include "head.h"#include "1.h"int main(){Linklist L;int n;printf("请输⼊约瑟夫环中的⼈数：");scanf("%d",&n);Createlist(L,n);printf("创建的约瑟夫环为：\n");Listtrave(L,n);printf("依次出局的结果为：\n");Solution(L,n);return 0;}head.h⽂件：#include "1.h"#include <stdio.h>#include <stdlib.h>typedef int Elemtype;typedef struct LNode{Elemtype data;struct LNode *next;}LNode,*Linklist;void Createlist(Linklist &L,int n){Linklist p,tail;L = (Linklist)malloc(sizeof(LNode));L->next = L;//先使其循环p = L;p->data = 1;//创建⾸节点之后就先给⾸节点赋值，使得后⾯节点赋值的操作能够循环tail = L;for(int i = 2;i <= n;i++){p = (Linklist)malloc(sizeof(LNode));p->data = i;p->next = L;tail->next = p;tail = p;}printf("已⽣成⼀个长度为%d的约瑟夫环！\n",n);}void Listtrave(Linklist L,int n)//遍历函数{Linklist p;p = L;for(int i = 1;i <= n;i++){printf("%3d",p->data);p = p->next;}printf("\n");}int Solution(Linklist L,int n){Linklist p,s;p = L,s = L;int count = 1;while(L){if(count != 3){count++;p = p->next;//进⾏不等于3时的移位}else{Linklist q;q = p;//⽤q保存p所指的位置，⽅便进⾏节点的删除if(s->next->data == s->data)//当只有⼀个元素的时候{printf("%3d\n",s->data);free(s);return OK;}else//当有两个及两个以上的元素的时候{count = 1;//先将count重置为1printf("%3d",p->data);//再打印出出局的值while(s->next != p){s = s->next;//将s移位到p的前驱节点处}p = p->next;//使p指向⾃⼰的下⼀个节点s->next = p;//进⾏删除free(q);}}}}1.h⽂件：#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2运⾏结果：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

约瑟夫环问题代码

/*约瑟夫环问题：设编号为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.调试分析在本次试验调试中很不顺利。

约瑟夫环(内含源代码)

数据结构课程设计实验学校：江西农业大学班级：软件1115班姓名：***学号：********课程：数据结构课程设计指导教师：***实验一：约瑟夫问题问题简述：约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。

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

约瑟夫问题是由古罗马著名的史学家Josephus提出的问题演变而来，所以通常称为Josephus问题。

改进约瑟夫问题的描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈, 每人有一个密码Ki（整数），留作其出圈后应报到Ki 后出圈。

报数方法采用顺时针报数和逆时针报数交替进行，初始密码可任意确定。

求最后剩下的人的编号。

这个就是约瑟夫环问题的实际场景，后来老师要求我们对要求中的每人所持有的密码以及第一次的报数上限值要用随机数产生。

因此约瑟夫环问题如果采用双向循环链表则能很好的解决。

循环链表的数据结构，就是将一个链表的尾元素指针指向队首元素。

p->link=head解决问题的核心步骤：先建立一个具有n个链结点，无头结点的循环链表，然后确定第一个报数人的位置，并不断地从链表中删除链结点，直到链表为空。

一、题目内容及要求【问题描述】编号是1，2，……,n的n个人按照顺时针方向围坐一圈，每个人只有一个密码（正整数）。

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

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

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

【要求】利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各个人的编号。

2）掌握线性表的基本操作，如插入、删除、检索等在链式存储结构上的运算。

二、实验环境（硬/软件要求）：Windows XP +三、概要设计利用单向循环链表存储结构模拟此过程，因为循环链表最后一个结点的指针域指向头结点，整个链表形成一人环，刚好和题中的“n个人按照顺时针方向围坐一圈，每个人只有一个密码（正整数）”内容要求一致，而且，循环链表中任一结点出发均可找到表中其他结点，利用这一优点可较容易地找出报数的人及下一个报数的人，最后按照出列的顺序用一个for语句实现。

约瑟夫环问题(Josephus)源代码讲解

原题：用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。

写出C程序。

（约瑟夫环问题 Josephus）提示：由于当某个人退出圆圈后，报数的工作要从下一个人开始继续，剩下的人仍然是围成一个圆圈的，可以使用循环表，由于退出圆圈的工作对应着表中结点的删除操作，对于这种删除操作频繁的情况，选用效率较高的链表结构，为了程序指针每一次都指向一个具体的代表一个人的结点而不需要判断，链表不带头结点。

所以，对于所有人围成的圆圈所对应的数据结构采用一个不带头结点的循环链表来描述。

设头指针为p，并根据具体情况移动。

为了记录退出的人的先后顺序，采用一个顺序表进行存储。

程序结束后再输出依次退出的人的编号顺序。

由于只记录各个结点的number值就可以，所以定义一个整型一维数组。

如：int quit[n];n为一个根据实际问题定义的一个足够大的整数。

代码：/******************************************************************** created: 2006/06/14 filename: C:\Documents and Settings\Administrator\桌面\tmpp\josephus.c file path: C:\Documents and Settings\Administrator\桌面\tmpp file base: josephus file ext: c author: A.TNG version: 0.0.1 purpose: 实现 Josephus 环问题用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。

写出C程序。

（约瑟夫环问题 Josephus）*********************************************************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <malloc.h> /* 结构体和函数声明 */ typedef struct _node_t { int n_num; struct _node_t *next; } node_t; node_t *node_t_create(int n); node_t *node_t_get(node_t **pn, int m); /* 功能函数实现 */ /* * name: node_t_create * params: * n [in] 输入要构造的链表的个数 * return: * 返回构造成功的环形单向链表指针 * notes: * 构造节点数量为 n 的环形单向链表* * author: A.TNG 2006/06/14 17:56 */ node_t * node_t_create(int n) { node_t *p_ret = NULL; if (0 != n) { int n_idx = 1; node_t *p_node = NULL; /* 构造 n 个 node_t */p_node = (node_t *) malloc(n * sizeof(node_t)); if (NULL == p_node) return NULL; else memset(p_node, 0, n * sizeof(node_t)); /* 内存空间申请成功 */ p_ret = p_node; for (; n_idx < n; n_idx++) { p_node->n_num = n_idx; p_node->next = p_node + 1;p_node = p_node->next; } p_node->n_num = n;p_node->next = p_ret; } return p_ret; } /* * name: main * params: * none * return: * int * notes: * main function * * author: A.TNG 2006/06/14 18:11 */ int main() { int n, m; node_t *p_list, *p_iter; n = 20; m = 6; /* 构造环形单向链表 */ p_list =node_t_create(n); /* Josephus 循环取数 */ p_iter = p_list; m %= n; while (p_iter !=p_iter->next) { int i = 1; /* 取到第 m-1 个节点 */ for (; i < m - 1; i++) { p_iter =p_iter->next; } /* 输出第 m 个节点的值 */ printf("%d\n", p_iter->next->n_num); /* 从链表中删除第 m 个节点 */ p_iter->next = p_iter->next->next; p_iter = p_iter->next; } printf("%d\n", p_iter->n_num); /* 释放申请的空间 */ free(p_list); system("PAUSE"); }。

约瑟夫环代码

#include <stdio.h>#include <malloc.h>分配内存的头文件#include <string.h>字符串typedef struct node{int number;char name[8];int pwd;struct node * next;}ListNode,*LinkList;void show(){printf("\n----------------约瑟夫环-----------------------\n");printf(" 约瑟夫环介绍(C) \n");printf(" 约瑟夫环测试(D) \n");printf(" 退出(Q) \n");printf("----------------------------------------------\n");printf("请选择：");}void content(){printf(" 编号为1，2… n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）一开始任选一个正整数作为报数的上限值m，从某一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他的顺时针方向上的下一个开始重新从1报数，如此下去，直至所有人全部出列为止，输出出列顺序。

");}void data()建立一个节点的信息{int i,j,k,m,n;//n为总人数,m为初值,k为密码,j为每个人序号，i为报数序号char a[8];//姓名LinkList p=(ListNode*)malloc(sizeof(ListNode));一个节点printf("总人数为：");scanf("%d",&n);printf("%d\n",n);if(n<=0){printf("人数输入错误,请重新输入!\n");scanf("%d",&n);}ListNode *q;q=p;printf("请输入姓名和密码!\n");for(j=1;j<=n;j++){scanf("%s",a); //姓名scanf("%d",&k); //密码if(k<=0){printf("密码值要大于0，请重新输入!");scanf("%d",&k);}p->number=j;strcpy(p->name,a);p->pwd=k;printf("第 %d个人姓名为:",j);printf("%s",p->name);printf(" 第 %d个人密码为:",j);printf("%d\n",p->pwd);if(j!=n){p->next=(ListNode*)malloc(sizeof(ListNode)); p=p->next;}p->next=q;}printf("初值为: ");scanf("%d",&m);printf("%d\n",m);if(m<=0){printf("初值输入错误，请重新输入!\n");scanf("%d",&m);}m--;printf("出列序号是:\n");while(p->next!=p){i=0;while(i!=m){p=p->next;i++;}q=p->next;p->next=q->next;printf("序号:%d",q->number);printf(" 姓名:%s\n",q->name); m=q->pwd;m--;free(q);}printf("序号:%d",p->number);printf(" 姓名:%s\n",p->name);free(p);Return 0;}void main(){char ch;while(1){show();scanf(" %c",&ch);printf("%c\n",ch);switch(ch){case 'C':content();break;case 'D':data();break;case 'Q'://exit(0);break;default:printf("选择错误!\n\n"); break;}}}。

约瑟夫问题面向对象(C++版)程序设计报告

Jose类中的成员函数分别为：
函数
相关说明
Jose(int boys, int interval, int begin=1);
构造函数，主要功能初始化各个参数，校验输出的m、n、s参数为int boys, int interval, int begin=1
void getWinner()const;
//构造函数
//-------------------------------------
BoyRing::BoyRing(int n)
{
if(n<2) throw exception(); //发生错误时自动跳出
pBegin = new Boy[n]; //申请一个新的Boy空间，pBegin指向该空间的开始处
for(int i=1; i<=n; i++)
{
pBegin[i-1].next = &pBegin[i%n];//形成链表
pBegin[i-1].code = i;//给孩子孩子编号
}
pivot = pCurrent = &pBegin[n-1];//各指针初始化
}
//------------------------------------
2详细设计
2.1程序结构
改程序分成三个抽象层次，第一层是应用层，直接指使Jose类对象去完成求解工作；第二层是Jose类层，描述Josephus问题的求解细节；第三层是BoyRing类层，辅助Jose类完成求解过程（上述三层间的关系描述如图J-1，这也是程序模块间的关系）。
图J-1.对象实现中程序模块的相互关系
void disengage();
利用指针实现小孩离队，无参数

约瑟夫问题的C++代码

#include<iostream>using namespace std;struct Node//定义节点的结构类型{int data;Node* next;};class CircularLinkedList//循环链表类{public:CircularLinkedList(){first=new Node;first->next=NULL;}CircularLinkedList(int n);//构建一个附有值的循环链表~CircularLinkedList();int Josephus(int num);//约瑟夫函数private:Node* first;};CircularLinkedList::CircularLinkedList(int n){first=new Node;Node * r=first;for(int i=1;i<=n;i++){Node* s=new Node;s->data=i;s->next=NULL;r->next=s;r=s;} //头插法初始化链表r->next=first; //最后一个元素的next志指向头结点}CircularLinkedList::~CircularLinkedList(){Node* p=first,*q;while(p->next!=first)//p指向最后一个结点时结束循环{q=p;p=p->next;delete q;}delete p;//删除头结点}int CircularLinkedList::Josephus(int num){Node* p=first,*q;if(num<=0)throw "输入错误！";while(first->next->next!=first){for(int i=1;i<num;i++) //p向后移动num位，指向要删除的元素的前一个结点{p=p->next;if(p==first) //若循环过程中出现p指向头结点，则跳过头结点{p=p->next;}}if(p->next==first) //若循环结束后p指向最后一个元素，则要跳过头结点，并让头结点的next指向要删除元素的下一个{p=first;q=p->next;p->next=q->next;//first->next=q->next;cout<<q->data<<" ";delete q;}else{q=p->next;p->next=q->next;cout<<q->data<<" ";delete q;}}cout<<endl;cout<<"最后一个数为：";return first->next->data;}void main(){int n,m;cout<<"请输入约瑟夫问题的人数和间隔人数：";cin>>n>>m;cout<<"依次删除："<<endl;CircularLinkedList Josephus1(n);//创建的对象调用第二个构造函数cout<<Josephus1.Josephus(m)<<endl;}。

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代码 1/*Joseph Problem2 *利⽤单循环链表解决约瑟夫问题。

3 *问题描述：将n个数链接成⼀个环，从第m个开始，每次从1计数到s时4 * 将s删除。

从下⼀个开始再次从1计数⾄s时删除s。

直到全5 * 部删除为⽌。

6 * */7 #include<stdio.h>8 #include<stdlib.h>910 typedef struct Node{11int data;12struct Node* next;13 }Node;14 typedef struct Node* LinkList;1516void CreateJosephLoop(LinkList *L,int number){17//创建Joseph环，在头结点中放⼊了元素1.18 *L = (LinkList)malloc(sizeof(struct Node));19if(!(*L)){20 printf("Error:malloc:0!\n");21 exit(1);22 }23 (*L)->next = (*L);24 (*L)->data = 1;25int i;26 LinkList new;27 LinkList tail = *L;28for(i = 1; i < number; i++){29new = (LinkList)malloc(sizeof(struct Node));30if(!new){31 printf("Error:malloc:1+i");32 exit(1);33 }34new->data = i+1;35new->next = tail->next;36 tail->next = new;37 tail = new;38 }39 }40void JosephProblem(int loopSize,int from,int stepBy){41//loopSize：Joseph环的⼤⼩42//form：从from开始43//stepBy：每次计数到stepBy时删除stepBy所指向的元素44 LinkList L;45 CreateJosephLoop(&L,loopSize);46int seekStart = 1;47while(seekStart < from){48 L = L->next;49 seekStart += 1;50 }51while(L->data != L->next->data){52int i = 1;53 LinkList temp;54for(i = 1;i < stepBy - 1; ){55 L = L->next;56 i++;57 }58 temp = L->next;59 printf("%d-->",temp->data);60 L->next = L->next->next;61 L = L->next;62free(temp);63 }64 printf("%d\n",L->data);65 }66int main(){67 JosephProblem(10,3,4);68 JosephProblem(41,1,3); 69return0;70 }。

约瑟夫环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程序设计有所帮助。

约瑟夫问题完整C程序代码

1）内容：约瑟夫(Joseph)问题的一种描述是:编号为1,2,..., n 的n 个人按顺时针方向围坐一圈, 每人持有一个密码(正整数)。

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

报m的人出列，将它的密码作为新的m值，再从下个人开始新一轮报数，如此反复，直到剩下最后一人则为获胜者。

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

2）要求：利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

3) 测试数据: n=7，7 个人的密码依次为：3，1，7，2，4，8，4 。

m的初值为20，则正确的出列顺序应为6，1，4，7，2，3，5。

完整代码：#include<stdio.h>#include<stdlib.h>struct person{int num;int order;struct person *next;};static struct person *head=NULL;struct person *CreatList(void){struct person *rear;struct person *p;int k=0;while(1){p=(struct person*)malloc(sizeof(struct person));p->order=++k;printf("\n请输入一个人所持的密码,输入0则建表结束:");scanf("%d",&p->num);if(p->num==0)break;if(head==NULL) head=p;else rear->next=p;rear=p;}if(rear!=NULL) rear->next=head;printf("\n建表结束\n");return head;}void josephus(struct person *p,int m) {int i,k;struct person* r;if(m==1)p=p->next;else{for(i=2;i<m;i++)p=p->next;}r=p->next;k=r->num;printf("%d ",k);printf("%d\n",r->order);p->next=r->next;free(r);if(p!=p->next)josephus(p->next,k);else{printf("%d ",p->num);printf("%d\n",p->order);}}void main(){int m;struct person *pos;CreatList();printf("请输入初始值m:");scanf("%d",&m);printf("密码顺序\n");pos=head;josephus(pos,m);}/* 测试数据，复制粘贴可用3172 4 8 4 0 20 */。

约瑟夫环问题源代码

#include<stdio.h>#include<stdlib.h>typedef struct node{int number;int psw;struct node *next;}Lnode ,*Linklist;void insert( Linklist * list , Linklist q , int e1 ,int e2 ){Linklist p;p=( Linklist )malloc( sizeof( Lnode ) ); //给链表分配预存空间p->number=e1;p->psw=e2;if(!*list){*list=p; //如果链表为空，则就将p作为头结点；p->next=NULL;}else{p->next=q->next; //插入节点qq->next=p;}}void creat( Linklist *jsp ,int n ){Linklist q=NULL ;Linklist list=NULL;int i,e;printf( "\n请输入每个人手中的密码：\n " );for( i=0 ; i<n ;i++ ){scanf("%d",&e);insert( &list ,q ,i+1 ,e );if( i==0 ) //第一次生成头结点，指向pq=list;elseq=q->next; //q指向下一个节点}q->next=list; //形成一个循环链表*jsp = list;}void shuchu( Linklist *jsp , int m ){Linklist q,p;int i;p=q=*jsp;while( q->next !=p )q=q->next; //q 指向p 的前一个节点printf( "\n出列的人的顺序编号:\n" );while( p->next !=p ) // 判断循环结束的标志{for( i=0;i<m-1;i++ ){ //P 指向要删除的节点，q指向p的前一个节点q=p;p=p->next;}q->next = p->next; //删除p 指向的节点printf("%d ",p->number);m=p->psw; //重新定义一个报数上限free(p); //释放节点pp=q->next; //指向下一个节点}printf( "\n\n最后有一个的序号为%d \n",p->number ); //读出最后一个数据}int main(){Linklist jsp;int n ,m;printf( "请输入约瑟夫环问题的人数：\n" );scanf("%d",&n); //输入约瑟夫环问题的总人数creat(&jsp , n);printf("\n请输入初始最大的出列序号\n");scanf("%d",&m);shuchu( &jsp , m );system("pause");return 0;}。

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"#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;}。