【数据结构C/C++】约瑟夫环以及约瑟夫生死者游戏的C/Java代码实现

已于 2023-10-09 18:56:44 修改
阅读量9.6k 收藏 41
点赞数 12
分类专栏： C++ 考研408 数据结构 文章标签： 指针 链表 算法 数据结构
于 2021-08-10 16:59:58 首次发布
ZhangBlossom@460219753
本文链接：https://blog.csdn.net/Zhangsama1/article/details/119547481
版权
数据结构 同时被 3 个专栏收录
37 篇文章 6 订阅
订阅专栏
考研408
19 篇文章 2 订阅
订阅专栏
C++
13 篇文章 6 订阅
订阅专栏

文章目录

前言

约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（分别用编号 1，2，3，…，n 表示）围坐在一张圆桌周围，从编号为 k 的人开始顺时针报数，数到 m 的那个人出列；他的下一个人又从 1 开始，还是顺时针开始报数，数到 m 的那个人又出列；依次重复下去，直到圆桌上剩余一个人。
在这里插入图片描述

如图所示，假设此时圆周周围有 5 个人，要求从编号为 3 的人开始顺时针数数，数到 2 的那个人出列：
出列顺序依次为：
编号为 3 的人开始数 1，然后 4 数 2，所以 4 先出列；
4 出列后，从 5 开始数 1，1 数 2，所以 1 出列；
1 出列后，从 2 开始数 1，3 数 2，所以 3 出列；
3 出列后，从 5 开始数 1，2 数 2，所以 2 出列；
最后只剩下 5 自己，所以 5 胜出。
约瑟夫环问题有多种变形，比如顺时针转改为逆时针等，虽然问题的细节有多种变数，但解决问题的中心思想是一样的，即使用循环链表，而循环链表与普通链表没有较大区别，只是将尾指针指向头指针而已。

一、概念了解

由上面提出的概念可以知道，约瑟夫环问题要求指定一个开始位置，从这个开始位置，顺时针或逆时针的循环读取下一个数据，且数到2的数据要求被移除，而其之后的数据接上来。因此我们需要做到：
1：构建一个链表且这个链表是首尾相连
2：若数据数到2，那么这个数据被移除
3：一个数据被删除后另一个数据要接上去
4：当链表只有一个数据时，结束
特殊情况：如果从编号1开始，且念到1的人出列，那么应该是上面情况

二、实验设计

1.链表初始化

#include <cstdio>
#include <iostream>
typedef struct Joseph
{
	int number;  //编号
	struct Joseph* next; //下一个地址
}Ring;
Ring* InitRing(int n)  //n为所需要构造的数量
{
	Ring* head,*tail,*p;  //头指针 新建指针 临时指针
	p= head = (Ring*)malloc(sizeof(Joseph)); //指针初始化
	head->number = 1; //编号1的元素
	head->next = NULL; //暂时指向空
	for (int i = 2; i <= n; i++)
	{
		tail = (Ring*)malloc(sizeof(Joseph)); //开辟新空间，存放编号
		tail->number = i;	//赋予编号
		tail->next = NULL; //暂时指向空
		p->next = tail; //衔接
		p = p->next;	//p指向下一个节点，以便下一次p的next能指向新节点
	}
	p->next = head;	//首尾相接
	return head;  //返回头指针
}

2.功能实现

void MoveRing(Ring* head, int start, int num)
{
	Ring* p, * tail; //tail用来指向要删除的数据的前一个位置，保证能数据删除后还能形成完整链条
	p= tail = head; 
	while (tail->next != head)//特殊处理，如果要删除的数据就是头指针指向的数据
		tail = tail->next;//那么为了保证删除该数据后还能形成一个环而作的处理
	while (p->number != start)//找到要删除的序号的位置
	{			
		tail = p;		//保证tail是要删除数据的前一位
		p = p->next;	//p为要删除的数据的位置
	}
	while (p->next != p)//最后的情况是tail->next=p->next,p=tail->next,因此最后p->next==p
	{
		for(int i = 1;i < num; i++)//达到了要删除的编号
		{
			tail = p;  //保证tail是要删除的前一位
			p = p->next;//p为要删除的数据
		}
		tail->next = p->next;//tail的下一位指向的是被删除的数据的下一位
		cout << "出列的序号是" << p->number << endl;;
		free(p);//释放被删除数据的空间
		p = tail->next;	//使得p指向被删除数据的下一位
	}
	cout << "胜利者的序号是" << p->number << endl;
	free(p);//函数全部结束，直接释放还没释放的空间，防止空间浪费
}

3.完整代码

#include <cstdio>
#include <iostream>
#include <algo.h>
typedef struct Joseph
{
	int number;  //编号
	struct Joseph* next; //下一个地址
}Ring;
Ring* InitRing(int n)  //n为所需要构造的数量
{
	Ring* head,*tail,*p;  //头指针 新建指针 临时指针
	p= head = (Ring*)malloc(sizeof(Joseph)); //指针初始化
	head->number = 1; //编号1的元素
	head->next = NULL; //暂时指向空
	for (int i = 2; i <= n; i++)
	{
		tail = (Ring*)malloc(sizeof(Joseph)); //开辟新空间，存放编号
		tail->number = i;	//赋予编号
		tail->next = NULL; //暂时指向空
		p->next = tail; //衔接
		p = p->next;	//p指向下一个节点，以便下一次p的next能指向新节点
	}
	p->next = head;	//首尾相接
	return head;  //返回头指针
}
void MoveRing(Ring* head, int start, int num)
{
	Ring* p, * tail; //tail用来指向要删除的数据的前一个位置，保证能数据删除后还能形成完整链条
	p= tail = head; 
	while (tail->next != head)//特殊处理，如果要删除的数据就是头指针指向的数据
		tail = tail->next;//那么为了保证删除该数据后还能形成一个环而作的处理
	while (p->number != start)//找到要删除的序号的位置
	{			
		tail = p;		//保证tail是要删除数据的前一位
		p = p->next;	//p为要删除的数据的位置
	}
	while (p->next != p)//最后的情况是tail->next=p->next,p=tail->next,因此最后p->next==p
	{
		for(int i = 1;i < num; i++)//达到了要删除的编号
		{
			tail = p;  //保证tail是要删除的前一位
			p = p->next;//p为要删除的数据
		}
		tail->next = p->next;//tail的下一位指向的是被删除的数据的下一位
		cout << "出列的序号是" << p->number << endl;;
		free(p);//释放被删除数据的空间
		p = tail->next;	//使得p指向被删除数据的下一位
	}
	cout << "胜利者的序号是" << p->number << endl;
	free(p);//函数全部结束，直接释放还没释放的空间，防止空间浪费
}

int main()
{
    printf("输入圆桌上的人数n:");
    int n;
   scanf("%d", &n);
    Ring* head = InitRing(n);
    printf("从第k人开始报数(k>1且k<%d)：", n);
    int k;
   scanf("%d", &k);
   printf("数到m的人出列：");
    int m;
   scanf("%d", &m);
    MoveRing(head, k, m);
    return 0;
}

4.效果

在这里插入图片描述

三、约瑟夫生死者游戏

1.概念

30个旅客同乘一条船，因为严重超载，必须将全船一半的旅客投入海中，其余人才能幸免遇难。大家同意一种办法：30人围成一圈，由第一个人数起，依次报数，数到第9人，便把他投入大海中，然后再从他的下一个人数起，数到第9人，再将他扔进大海中，如此循环地进行，直到剩下15个乘客为止。
要求实现如下功能：
1.建立一个具有30个结点的单循环链表；
2.生者与死者的选择：从位置为1的结点开始数，数到第8个结点，将其下一个结点从单循环链表中删除，然后，再从被删除结点的下一个结点开始数，数到第8个结点，再将其下一个结点删除，如此下去，直到剩下15个结点为止；
3.输出所有生者的位置。

2.解决

可以发现约瑟夫生死者游戏只不过是再约瑟夫环上增加了一些限制条件，例如:
1.最后需要剩余人数为15人
2.数到9的人下船
3.报出幸存者的编号
知道了这些，我们只需要再约瑟夫环的代码上进行一些修改就可以得到约瑟夫生死者游戏的代码

3.C实现

#include <cstdio>
#include<cstdlib>
#include<iomanip>
typedef int Status;
typedef int ElemType;
typedef char cElemType;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define MAXSIZE 20
#define make (struct student*)malloc(sizeof(struct student));
using namespace std;
typedef struct Joseph
{
	int remain; //剩余人数
	int number;  //编号
	struct Joseph* next; //下一个地址
}Ring;
Ring* InitRing(int n)  //n为所需要构造的数量
{
	Ring* head,*tail,*p;  //头指针 新建指针 临时指针
	p= head = (Ring*)malloc(sizeof(Joseph)); //指针初始化
	head->remain = 30; //初始剩余人数30
	head->number = 1; //编号1的元素
	head->next = NULL; //暂时指向空
	for (int i = 2; i <= n; i++)
	{
		tail = (Ring*)malloc(sizeof(Joseph)); //开辟新空间，存放编号
		tail->number = i;	//赋予编号
		tail->next = NULL; //暂时指向空
		p->next = tail; //衔接
		p = p->next;	//p指向下一个节点，以便下一次p的next能指向新节点
	}
	p->next = head;	//首尾相接
	return head;  //返回头指针
}
void MoveRing(Ring* head, int start, int num)
{
	Ring* p, * tail; //tail用来指向要删除的数据的前一个位置，保证能数据删除后还能形成完整链条
	p= tail = head; 
	while (tail->next != head)//特殊处理，如果要删除的数据就是头指针指向的数据
		tail = tail->next;//那么为了保证删除该数据后还能形成一个环而作的处理
	while (p->number != start)//找到要删除的序号的位置
	{			
		tail = p;		//保证tail是要删除数据的前一位
		p = p->next;	//p为要删除的数据的位置
	}
	while (head->remain>15)//最后的情况是tail->next=p->next,p=tail->next,因此最后p->next==p
	{
		for(int i = 1;i < num; i++)//达到了要删除的编号
		{
			tail = p;  //保证tail是要删除的前一位
			p = p->next;//p为要删除的数据
		}
		tail->next = p->next;//tail的下一位指向的是被删除的数据的下一位
		cout << "出列的序号是" << p->number << endl;
		free(p);//释放被删除数据的空间
		p = tail->next;	//使得p指向被删除数据的下一位
		head->remain -= 1; //有人被移除，剩余人数减1
	}
	for (int j = 1; j <= 15; j++)
	{
		cout << "幸存者的序号是" << p->number << endl; //输出胜利者的序号
		p = p->next; //让p指向下一个地址
	}
	free(head);//函数全部结束，直接释放还没释放的空间，防止空间浪费
}


int main()
{
    printf("输入圆桌上的人数n:");
    int n;
   scanf("%d", &n);
    Ring* head = InitRing(n);
    printf("从第k人开始报数(k>1且k<%d)：", n);
    int k;
   scanf("%d", &k);
   printf("数到m的人出列：");
    int m;
   scanf("%d", &m);
    MoveRing(head, k, m);
    return 0;
}

4.Java实现

public class JosephusRing{
    /**
     *
     * @param numOfPeople 总人数
     * @param perpleOrder 出去的人叫道的号
     * @param startNum  从第几个人开始
     */
    public static void josephusRing(int numOfPeople,int perpleOrder,int startNum){
        Queue<Integer>queue=new Queue<Integer>();
        for(int i=0;i<numOfPeople;i++){ //把这几个人入队列
            queue.enqueue(i);
        }
        for(int i=0;i<startNum;i++){//找到开始的那个人的编号 把他放在队头
            queue.enqueue(queue.dequeue());
        }
        while(numOfPeople>0){
            for(int i=1;i<perpleOrder;i++){//假设叫道3的出去,那么从1开始 1 2 3 循环两次 然后队头就是要出去的
                queue.enqueue(queue.dequeue());
            }
            System.out.println("出去的人的编号是:"+queue.dequeue());
            numOfPeople--;
        }

    }
      public static void main(String[] args) {
        new JosephusRing().josephusRing(5,3,0);
    }
}

在这里插入图片描述

408考研各数据结构C/C++代码（Continually updating）

408考研各数据结构C/C++代码（Continually updating）
这个模块是我应一些朋友的需求，希望我能开一个专栏，专门提供考研408中各种常用的数据结构的代码，并且希望我附上比较完整的注释以及提供用户输入功能，ok，fine，这个专栏会一直更新，直到我认为没有新的数据结构可以讲解了。
目前我比较熟悉的数据结构如下：
数组、链表、队列、栈、树、B/B+树、红黑树、Hash、图。
所以我会先有空更新出如下几个数据结构的代码，欢迎关注。 当然，在我前两年的博客中，对于链表、哈夫曼树等常用数据结构，我都提供了比较完整的详细的实现以及思路讲解，有兴趣可以去考古。

ZhangBlossom
关注
专栏目录
数据结构课程设计：约瑟夫生者死者游戏（c++实现、单循环链表、输出死者姓名和编号、附可执行源代码）
m0_64336416的博客
06-23 6151
（c++、单循环链表）有N个旅客同乘一条船，因为严重超载，加上风高浪大，危险万分；因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免于难；无奈，大家只得同意这种办法，并议定N个人围成一圈，由第一个人开始，依次报数，数到第9人，便把他投入大海中，然后再从他的下一个人开始，数到第9人，再把他投入大海中，如此循环地进行，直到剩下N/2个乘客为止。问哪些乘客是将被投入大海的？输出这些乘客的姓名和位置。......
约瑟夫死亡游戏（C语言代码）
10-12
约瑟夫生死游戏的C语言代码及设计思路及逻辑，循环链表的整体算法思想
约瑟夫生死游戏
07-02
功能完整的约瑟夫生死游戏代码，包含课程设计。
[源码和文档分享]使用C++实现的约瑟夫生死游戏
qq_38474647的博客
12-18 354
一、项目简介 约瑟夫生者死者游戏的大意是：30个旅客同乘一条船，因为严重超载，加上风高浪大危险万分；因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免于难。无奈，大家只得统一这种方法，并议定30个人围成一圈，由第一个人开始，依次报数，数到第9人，便将他投入大海中，然后从他的下一个人数起，数到第9人，再将他投入大海，如此循环，直到剩下15个乘客为...
趣味算法------约瑟夫环
最新发布
markingyi的博客
08-16 968
经典算法题，通过简单的规律找到问题的求解方法并且使用短代码实现。
约瑟夫双向生死游戏c语言代码,数据结构程序设计——约瑟夫双向生死杀人游戏...
weixin_36180385的博客
05-19 1586
首先是主函数：/***版权所有(C)2017，ShangWenZhe**文件名称：main.cpp*文件标识：无*内容摘要：本文件的作用是调用算法库里面的函数，完成题目要求。*其它说明：无*当前版本：V1.0*作者：尚文哲*完成日期：2017,12,15**/#include#include#include#include"Jd.h"int main(){int total = 30;//总人数i...
队列，栈，克鲁斯卡尔，约瑟夫生死者游戏等数据结构代码.rar
08-17
本资源包含与数据结构相关的代码实现，包括队列、栈、克鲁斯卡尔算法和约瑟夫环问题，分别用C语言和C++编写。下面我们将详细探讨这些主题。 1. **队列**： 队列是一种先进先出（FIFO，First In First Out）的数据...
数据结构 用双向链表实现约瑟夫环
11-07
数据结构大作业，c++用双向链表实现约瑟夫环，内含.h与.cpp
约瑟夫生死者游戏.rar
08-10
《约瑟夫生死者游戏》是一个著名的算法问题，源自古代犹太人的一个传说。在这个问题中，一群囚犯被围成一个圈，按照顺时针方向依次报数，每报到特定数字的囚犯就会被处决，直到只剩下最后一个人为止。这个经典的算法...
精选_基于C++实现的约瑟夫生者死者游戏_源码打包
03-06
《约瑟夫生者死者游戏的C++实现详解》 约瑟夫问题，又称为约瑟夫环，是一个著名的理论问题，源自一个古老的犹太故事。在这个游戏中，人们站成一个圈，按照一定的顺序报数，每次报到特定数字的人会被剔除出圈，直至...
约瑟夫生死游戏 c语言
03-22
30个人同坐一条船，严重超载，船上必须剩15人才能保证安全，将30个人围成一圈，每数第9个就跳下去，问都哪个位置的人跳下去了？？
约瑟夫环游戏
06-23
MFC开发的约瑟夫环小游戏,对话框的界面，可以自由制定游戏的规则
约瑟夫生死环游戏代码
11-24
这是约瑟夫生死环游戏的实现,要点:循环链表 数据结构
约瑟夫生死游戏c语言程序,基于C语言实现的约瑟夫生者死者游戏
weixin_35148673的博客
05-20 613
1 项目简介约瑟夫生者死者游戏的大意是：30个旅客同乘一条船，因为严重超载，加上风高浪大危险万分；因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免于难。无奈，大家只得统一这种方法，并议定30个人围成一圈，由第一个人开始，依次报数，数到第9人，便将他投入大海中，然后从他的下一个人数起，数到第9人，再将他投入大海，如此循环，直到剩下15个乘客为止。问哪些位置是将被扔下大海的位置。本游戏的...
约瑟夫生死小游戏
weixin_47360674的博客
07-01 395
约瑟夫生者死者小游戏 30 个人在一条船上，超载，需要 15 人下船。 于是人们排成一队，排队的位置即为他们的编号。 报数，从 1 开始，数到 9 的人下船。 如此循环，直到船上仅剩 15 人为止，问都有哪些编号的人下船了呢？ # 首先来一个超载的小船30人 people = list(range(1,31)) # 这个编号是1~30 # 人数大于15就继续踢人 while len(people) > 15: i = 1 # 将前八个人移动到末尾，将第九个踢出 while i <
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZhangBlossom

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值