约瑟夫问题的C语言算法(循环链表)
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运⾏结果：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
约瑟夫环问题 数据结构C语言描述
void Josephus()
{
Linklist L;
Node *p,*r,*q;
int m,n,C,j;
L=(Node*)malloc(sizeof(Node)); /*初始化单向循环链表*/
if(L==NULL) { printf("\n 链表申请不到空间!");return;}
L->next=NULL;
r=L;
printf("请输入人数 n 的值(n>0):");
scanf("%d",&n);
for(j=1;j<=n;j++)
/*建立链表*/
{
p=(Node*)malloc(sizeof(Node));
if(p!=NULL)
{
printf("请输入第%d 个人的密码:",j);
scanf("%d",&C);
约瑟夫环问题
约瑟夫问题的一种描述为：编号 1,2,…,n 的 n 个人按顺时针方向围坐一圈，每个人持有一 个密码（正整数）。一开始任选一个报数上限值 m,从第一个人开始顺时针自 1 开始顺序报 数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从他在顺时针方向上 的下一个人开始重新从 1 报数，如此下去，直至所有的人全部出列为止。试设计一个程序， 求出出列顺序。利用单向循环链表作为存储结构模拟此过程，按照出列顺序打印出各人的编 号。
/*获得新密码*/
n--;
q->next=p->next; /*p 出列*/
r=p;
p=p->next;
free(r);
C语言单向循环链表实现实现约瑟夫环
C语言实现约瑟夫环问题------单向循环链表实现问题描述：有n个人围成一圈进行报数游戏，从第一个人开始报到m的人出圈，接下来有从下一个人开始，。
一次这样往复，直到最后一个人也出圈，求他们的出圈顺序？（例如8个人，凡报3的人出圈，则他们出圈顺序是3 ，6, 1，，5 ，2 ，8，4 ，7）#include<stdio.h>#include<stdlib.h>typedef struct node{int value;struct node *next;}NODE;//*********************建立循环链表(尾插法建立)***********//NODE *createlink(int number){NODE *head=NULL,*p=NULL,*q=NULL;int i=1;head=(struct node*)malloc(sizeof(struct node)); //***建立第一个节点***//head->value=i;p=head;for(i=2;i<=number;i++) //***建立剩下的number-1节点****//{q=(struct node*)malloc(sizeof(struct node));if(q==0) return 0;p->next=q;p=q;p->value=i;}p->next=head;return head;}//*****************建立约瑟夫环********************// void jose(NODE *p,int number,int n){int i,j,g=0;NODE *q=NULL;for(i=1;i<=number;i++){for(j=1;j<n-1;j++){p=p->next;}q=p->next; //***q用来记录要删除的节点*****//p->next=q->next; //****删去q节点******//p=p->next;printf("第%3d个出圈号是：%3d\n",i,q->value);free(q);}printf("\n");// p->next=NULL; 此表达式不能出现在此处，最后一个节点删除后就不存在了}//***********************主函数*************************//int main( ){int number=0;int n=0;printf("请输入总人数number和出拳编号n:\n");scanf("%d",&number);scanf("%d",&n);NODE *head=NULL;head=createlink(number);jose(head,number,n);system("PAUSE");return 1;}。
C++编写的 约瑟夫环问题 代码
程序源代码：#include <stdio.h>#include <malloc.h>#include<conio.h>#include <stdlib.h>#include<ctime>#define NULL 0typedef struct Node{int m;//密码int n;//序号struct Node *next;}Node,*Linklist;Linklist create(int z) //生成循环单链表并返回,z为总人数{int i,mm;Linklist H,r,s;H=NULL;printf("请按顺序依次为每个人添加密码：");for(i=1;i<=z;i++){printf("\ninput cipher=");scanf("%d",&mm);s=(Linklist)malloc(sizeof(Node));s->n=i;s->m=mm;printf("%d号的密码%d",i,s->m);if(H==NULL)//从链表的第一个节点插入{H=s;r=H;}else//链表的其余节点插入{r->next=s;r=s;//r后移}//for结束r->next=H;/*生成循环单链表*/return H;}void search(Linklist H,int m0,int z)//用循环链表实现报数问题{int count=1;//count为累计报数人数计数器int num=0;//num为标记出列人数计数器Linklist pre,p;p=H;printf("出列的顺序为:");while(num<z){do{count++;pre=p;p=p->next;}while(count<m0);｛pre->next=p->next;printf("%d ",p->n);m0=p->m;free(p);p=pre->next;count=1;num++;}//while结束}void clean(){int system(const char *string);int inquiry;printf("请问需要清除上一次操作记录吗（1.清屏/2.不清屏）...?\n"); scanf("%d",&inquiry);if(inquiry ==1)system("cls");}void text(){int m0,z,i, choose,k=1; //k用来阻止第一次进入程序清屏操作Linklist H;bool chooseFlag=false;while(1){if(k!=1)clean();k++;while(!chooseFlag){printf(" ……………………欢迎进入约瑟夫环问题系统…………………… \n"); printf( "* 1.输入约瑟夫环数据 * \n"); printf(" * 2.什么是约瑟夫环 * \n"); printf(" * 3.退出系统 * \n"); printf("........................................................ \n"); printf("请输入相应的数字进行选择: ");scanf("%d",&choose);for(i=1;i<=4;i++){if(choose==i) { chooseFlag=true; break;}else chooseFlag=false;}if(!chooseFlag) printf("Error Input!\n");} //end while(!chooseFlag)if(choose==1) //if 开始{printf("Input how many people in it:");//z为总人数scanf("%d",&z);if(z<=30){H=create(z);//函数调用printf("\nInput the start code m0=");scanf("%d",&m0);search(H,m0,z);printf("\n\n\n");}else{printf("超过最大输入人数\n");break;}}else if(choose==2){printf("\n约瑟夫环问题：设有n个人，其编号分别为1，2，3，…，n，安装编号顺序顺时针围坐一圈。
约瑟夫生死游戏(C++)数据结构实现
约瑟夫生死游戏(C++)数据结构实现本文档为约瑟夫生死游戏的C++数据结构实现文档，旨在详细介绍如何使用C++语言实现约瑟夫生死游戏的功能。
1：引言1.1 背景约瑟夫生死游戏是一个经典的数学问题，由约瑟夫·斯特恩提出。
问题描述如下：有n个人围成一圈，从某个人开始，每次顺时针报数m个人，报到m的人出局，直到剩下最后一个人为止。
1.2 目的本文档旨在指导开发人员使用C++语言实现约瑟夫生死游戏的功能，包括实现报数、出局等基本操作，并提供相应的测试样例和使用说明。
2：设计2.1 数据结构设计约瑟夫生死游戏的核心是一个环形链表，链表中的每个节点代表一个人。
每个节点包含两部分数据：该人的编号和指向下一个节点的指针。
链表的最后一个节点指向第一个节点，形成环形结构。
2.2 算法设计- 初始化链表：根据输入的人数创建相应数量的节点，并通过指针连接起来，形成环形链表。
- 报数出局：从指定的起始位置开始顺时针遍历链表，依次报数，当报到m时，将该节点从链表中移除。
- 判断游戏结束：当只剩下最后一个节点时，游戏结束。
2.3 功能设计- 初始化游戏：根据输入的人数和报数间隔，创建约瑟夫生死游戏实例。
- 开始游戏：执行报数出局操作，直到游戏结束。
- 获取胜利者：返回最后剩下的节点的编号。
3：实现下面给出C++语言实现约瑟夫生死游戏的核心代码。
```cppinclude<iostream>using namespace std;// 定义环形链表节点结构体struct Node {int id;Node next;};class JosephusGame {public:// 构造函数，初始化环形链表JosephusGame(int n, int m) {// 创建第一个节点Node firstNode = new Node;firstNode->id = 1;firstNode->next = NULL;// 依次连接剩余节点Node prevNode = firstNode;for (int i = 2; i <= n; i++) { Node newNode = new Node; newNode->id = i;newNode->next = NULL;prevNode->next = newNode;prevNode = newNode;}// 最后一个节点和第一个节点，形成环形结构prevNode->next = firstNode;// 初始化成员变量this->head = firstNode;this->count = n;this->interval = m;}// 游戏主循环void playGame() {Node currentNode = this->head;while (this->count > 1) {// 找到要出局的节点的前一个节点for (int i = 1; i < this->interval; i++) { currentNode = currentNode->next;}// 删除当前节点Node removedNode = currentNode->next; currentNode->next = removedNode->next; delete removedNode;this->count--;// 移动当前节点到下一个节点currentNode = currentNode->next;}}// 获取胜利者的编号int getWinner() {return this->head->id;}private:Node head; // 链表头节点int count; // 当前剩余人数int interval; // 报数间隔};int mn() {int n, m;cout << \。
约瑟夫环问题
约瑟夫环问题问题描述：有n个⼈，编号分别从0到n-1排列，这n个⼈围成⼀圈，现在从编号为0的⼈开始报数，当报到数字m的⼈，离开圈⼦，然后接着下⼀个⼈从0开始报数，依次类推，问最后只剩下⼀个⼈时，编号是多少？分析：这就是著名的约瑟夫环问题，关于来历不再说明，这⾥直接分析解法。
解法⼀：蛮⼒法。
我曾将在⼤⼀学c语⾔的时候，⽤蛮⼒法实现过，就是采⽤标记变量的⽅法即可。
解法⼀：循环链表法。
从问题的本质⼊⼿，既然是围成⼀个圈，并且要删除节点，显然符合循环链表的数据结构，因此可以采⽤循环链表实现。
解法三：递推法。
这是⼀种创新的解法，采⽤数学建模的⽅法去做。
具体如下：⾸先定义⼀个关于n和m的⽅程f(n,m)，表⽰每次在n个编号0，1，...，n-1中每次删除的报数为m后剩下的数字，在这n个数字中，第⼀个被删除的数字是(m-1)%n，为了简单，把(m-1)%n记作k，那么删除k之后剩下的数字为0，1，2，...，k-1，k+1，...，n-1并且下⼀次删除的数字从k+1开始计数，这就相当于剩下的序列中k+1排在最前⾯，进⽽形成k+1,..,n-1,0,1,2,...,k-1这样的序列，这个序列最后剩下的数字应该和原序列相同，由于我们改变了次序，不能简单的记作f(n-1,m),我们可以记作g(n-1,m),那么就会有f(n,m)=g(n-1,m).下⼀步，我们把这n-2个数字的序列k+1,..,n-1,0,1,2,...,k-1做⼀个映射，映射的结果是形成⼀个从0到n-2的序列。
k+1对0，k+2对1，......，n-1对n-k-2，0对n-k-1，1对n-k，....，k-1对n-2这样我们可以把这个映射定义为p,则p(x)=(x-k-1)%n,它表⽰如果映射前的数字是x，映射后为(x-k-1)%n,从⽽这个映射的反映射问为p-1(x)=(x+k+1)%n由于映射之后的序列和原始序列具有相同的形式，都是从0开始的序列，所以可以⽤函数f来表⽰，即为f(n-1,m)，根据映射规则有：g(n-1,m)=p-1[f(n-n,m)]=[f(n-1,m)+k+1]%n,最后把之前的k=(m-1)%n带⼊式⼦就会有f(n,m)=g(n-1,m)=[f(n-1,m)+m]%n.这样我们就可以得出⼀个递推公式，当n=1时，f(n,m)=0;当n>1时，f(n,m)=[f(n-1,m)+m]%n;有了这个公式，问题就变得多了。
实验一：约瑟夫问题
实验一：约瑟夫问题问题描述：用数组和链表存储方式实现约瑟夫问题。
约瑟夫问题：n个人围成一个圆圈，首先第1个人从1开始一个人一个人顺时针报数，报到第m个人，令其出列。
然后再从下一个人开始，从1顺时针报数，报到第m个人，再令其出列，…，如此下去，直到圆圈中只剩一个人为止。
此人即为优胜者。
基本要求：用顺序存储和链式存储方式实现。
试验报告内容：1．问题描述：设有n个人围坐在圆桌周围，现从某个位置m（1≤m≤n）上的人开始报数，报数到k 的人就站出来。
下一个人，即原来的第k+1个位置上的人，又从1开始报数，再报数到k的人站出来。
依此重复下去，直到全部的人都站出来为止。
2. 算法描述：可以先建一个单向循环链表；而整个“约瑟夫环”问题的过程，最终是把这个链表删空为止。
但在删时不能顺着删，而是按该问题的方案来删。
3.源程序#include <stdio.h>#include <stdlib.h>#define MAX_NODE_NUM 100#define TRUE 1U#define FALSE 0Utypedef struct NodeType{int id; /* 编号 */int cipher; /* 密码 */struct NodeType *next;} NodeType;/* 创建单向循环链表 */static void CreaList(NodeType **, const int);/* 运行 "约瑟夫环 "问题 */static void StatGame(NodeType **, int);/* 打印循环链表 */static void PrntList(const NodeType *);/* 得到一个结点 */static NodeType *GetNode(const int, const int);/* 测试链表是否为空, 空为TRUE，非空为FALSE */static unsigned EmptyList(const NodeType *);int main(void){int n, m;NodeType *pHead = NULL;while (1){printf( "请输入人数n（最多%d个）: ", MAX_NODE_NUM); scanf( "%d ", &n);printf( "和初始密码m: ");scanf( "%d ", &m);if (n > MAX_NODE_NUM){printf( "人数太多，请重新输入！\n ");continue;}elsebreak;}CreaList(&pHead, n);printf( "\n------------ 循环链表原始打印 -------------\n "); PrntList(pHead);printf( "\n-------------- 出队情况打印 ---------------\n "); StatGame(&pHead, m);printf( "\n\ "约瑟夫环\ "问题完成!\n ");return 0;}static void CreaList(NodeType **ppHead, const int n){int i, iCipher;NodeType *pNew, *pCur;for (i = 1; i <= n; i++){printf( "输入第%d个人的密码: ", i);scanf( "%d ", &iCipher);pNew = GetNode(i, iCipher);if (*ppHead == NULL){*ppHead = pCur = pNew;pCur-> next = *ppHead;}else{pNew-> next = pCur-> next;pCur-> next = pNew;pCur = pNew;}}printf( "完成单向循环链表的创建!\n ");}static void StatGame(NodeType **ppHead, int iCipher){int iCounter, iFlag = 1;NodeType *pPrv, *pCur, *pDel;pPrv = pCur = *ppHead;/* 将pPrv初始为指向尾结点，为删除作好准备 */while (pPrv-> next != *ppHead)pPrv = pPrv-> next;while (iFlag) /* 开始搞了! */{/* 这里是记数，无非是移动iCipher-1趟指针! */for (iCounter = 1; iCounter < iCipher; iCounter++) {pPrv = pCur;pCur = pCur-> next;}if (pPrv == pCur) /* 是否为最后一个结点了 */iFlag = 0;pDel = pCur; /* 删除pCur指向的结点，即有人出列 */pPrv-> next = pCur-> next;pCur = pCur-> next;iCipher = pDel-> cipher;printf( "第%d个人出列, 密码: %d\n ",pDel-> id, /* 这个编号标识出列的顺序 */pDel-> cipher);free(pDel);}*ppHead = NULL; /* 没人了！为了安全就给个空值 */}static void PrntList(const NodeType *pHead){const NodeType *pCur = pHead;if (EmptyList(pHead))return;do{printf( "第%d个人, 密码: %d\n ", pCur-> id,pCur-> cipher); pCur = pCur-> next;} while (pCur != pHead);}static NodeType *GetNode(const int iId, const int iCipher){NodeType *pNew;pNew = (NodeType *)malloc(sizeof(NodeType));if (!pNew){printf( "Error, the memory is not enough!\n ");exit(-1);}pNew-> id = iId;pNew-> cipher = iCipher;pNew-> next = NULL;return pNew;}static unsigned EmptyList(const NodeType *pHead){if (!pHead){printf( "The list is empty!\n ");return TRUE;}return FALSE;}4.实验测试数据（要求有多组）：第一组测试结果人数n为7, 初始密码m为20第1个人, 密码: 3第2个人, 密码: 1第3个人, 密码: 7第4个人, 密码: 2第5个人, 密码: 4第6个人, 密码: 8第7个人, 密码: 4-------------- 出队情况打印 ---------------第6个人出列, 密码: 8第1个人出列, 密码: 3第4个人出列, 密码: 2第7个人出列, 密码: 4第2个人出列, 密码: 1第3个人出列, 密码: 7第5个人出列, 密码: 4第二组测试结果人数n为8, 初始密码m为15第1个人, 密码: 5第2个人, 密码: 4第3个人, 密码: 3第4个人, 密码: 2第5个人, 密码: 9第6个人, 密码: 1第7个人, 密码: 7第8个人, 密码: 8-------------- 出队情况打印 ---------------第7个人出列, 密码: 7第6个人出列, 密码: 1第8个人出列, 密码: 8第3个人出列, 密码: 3第1个人出列, 密码: 5第4个人出列, 密码: 2第2个人出列, 密码: 4第5个人出列, 密码: 95.总结：1. 通过本次上机实践,对链表存储结构有了更深的理解和把握.2. 通过本次上机实践,应用链表的知识解决和分析问题的能力有了新的提高.3. 通过上机实践,掌握了用高级语言实现算法的基本步骤和方法.（最前面加班级、学号、姓名）。
约瑟夫问题的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;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算法：n个人围成一圈，每个人都有一个互不相同的密码，该密码是一个整数值，选择一个人作为起点，然后顺时针从1到k（k为起始点手中的密码值）数数。
数到k的人退出圈子，然后从下一个人开始继续从1到j（j为刚退出圈子人的密码数）数数，数到j的人退出圈子。
重复上述操作，直到最后一人
代码如下：
# include <stdio.h>
# include <stdlib.h> //free(),malloc()所在库文件
# define n 9 //数字个数
# define overflow 0 //判断溢出情况
int keyw[n]={4,7,5,9,3,2,6,1,8}; //欲处理数的数组
typedef struct lnode //声明结构体，包括两个成员，一个是数值，另一个是指向下个结点的指针
{
int keyword;
struct lnode *next;
}lnode,* linklist;
void joseph(linklist p,int m,int x) //定义约瑟夫环函数：p为循环列表头结点，m 为初始值，x为数组长度
{
linklist q; //声明变量
int i;
if(x==0)return;
q=p;
m%=x;
if(m==0)m=x;
for(i=1;i<=m;i++) //找到下一个结点
{
p=q;
q=p->next;
}
p->next=q->next;
i=q->keyword;
printf("%5d",q->keyword);
free(q);
joseph(p,i,x-1); //递归调用
}
int main()
{
int i,m;
linklist lhead,p,q;
lhead=(linklist)malloc(sizeof(lnode)); //申请结点空间
// if(!lhead) return overflow; 此处为判断溢出情况，可省略lhead->keyword=keyw[0];
lhead->next=NULL;
p=lhead;
for(i=1;i<9;i++) //创建循环列表
{
if(!(q=(linklist)malloc(sizeof(lnode))))return overflow;
q->keyword=keyw[i];
p->next=q;
p=q;
}
p->next=lhead;
printf("请输入初始值：\n");
scanf("%d",&m);
printf("输出顺序为：\n");
joseph(p,m,n);
printf("\n");
}
运行结果如下：。