数据结构实验——约瑟夫环问题

于 2023-12-24 19:42:54 发布
阅读量672 收藏 6
点赞数 5
分类专栏： 学习笔记 文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qint__/article/details/135185565
版权

实验要求：

从键盘输入人数N（N<50）及N个人的编号（整型）、姓名、性别和年龄，正向建立带头节点的循环链表；

输出循环链表各结点的值；

输入开始报数的人的编号S、间隔的个数M和剩余人数X；

在循环链表中查找到编号为S的结点；

从1开始向后报数，将报M的人（结点）从循环链表中删除，并输出该人的编号；

从刚才被删除人的下一个人开始重复步骤5，直至最后只剩下 X 个人为止；

输出最后剩余的人的编号、姓名、性别和年龄。

1、实验设计思路：

  很自然的想到用动态链表解决这一问题，根据题目要求需要建立带头节点的循环链表，结合头结点和循环链表的定义很容易实现这一功能。其次就是人这一类型的抽象，根据题目要求很容易设计出一个人的类型，其中包括人的编号姓名性别和年龄。这里还是采用头插法再通过一个逆向函数（ListInvert）实现正向创建链表；

  尤瑟夫主干算法直接根据定义，从开始报数的人开始，每个一定的数目就将报到M的人从链表中删去再从下一个人开始继续这个过程。这里采用的是循环链表所以要非常注意报到M的时候可能是头指针L而不是人，如果把头指针L删除的话会产生非常严重的后果所以要特判边界情况。最后根据剩余人数设计循环，实现这一算法。

  除了链表、人的类型和算法主体，还需要设计打印函数和销毁函数来完成实验要求；

2、主要函数实现和代码说明 ：

2.1人的类型
struct Person//人的类型	{
	string id;//唯一的id
	int age;//年龄
	bool sex;//性别(1为男性,0为女性)
	string name;//姓名
};
节点类型
struct LNode//节点(包括人和它的下一个节点的地址)
{
	Person data;
	LNode* next;
};
链表的相关函数（链表的创建、置逆、打印、求表长、删除元素、头插法和查找）
LinkList InitList()//建立一个循环链表
{
	LinkList L = new LNode;//在内存中为头节点开辟一段空间
	if (!L)exit(1);
	L->next = L;
	return L;//用返回的方式拿出这段内存
}
int LocateElem(LinkList L, string id)//由id找到pos
{
	int pos = 0;//元素编号从1开始
	LinkList p = L;
	while (p->data.id != id)
	{
		p = p->next; pos++;
	}
	return pos;
}
void DestroyList(LinkList L)//销毁一个链表
{
	LinkList p = L;
	while (p!=L)
	{
		LinkList s = p;
		p = p->next;
		delete s;
	}
	L = NULL;
}
void ListInsert(LinkList L)
{
	LinkList s = new LNode;
	if (!s)exit(1);
	cout << "************************" << endl;
	cout << "请依次输入添加人员的信息:" << endl;//给节点的信息赋值;
	cout << "编号为(编号两两之间不能相同):" << endl; cin >> s->data.id;
	cout << "姓名为:" << endl; cin >> s->data.name;//用malloc分配空间时给名字赋值时会报错,因为malloc不能提供string的构造函数;
	cout << "性别为(1为男0为女):" << endl; cin >> s->data.sex;
	cout << "年龄为:" << endl; cin >> s->data.age;
	cout << "添加成功!" << endl;
	system("pause");
	s->next = L->next;
	L->next = s;//头插法逆向建立链表;
	system("cls");
}
void ListInvert(LinkList L)//链表置逆
{
	LinkList p = L->next;
	L->next = L;//将头指针重置
	while (p != L)//从第一个元素开始依次头插法完成逆序转正序
	{
		LinkList s = new LNode;//将原链表的各个节点重新插入到置逆的链表中;
		s->data.id = p->data.id;
		s->data.name = p->data.name;
		s->data.sex = p->data.sex;
		s->data.age = p->data.age;
		s->next = L->next;
		L->next = s;
		p = p->next;
	}
}
void ListPrint(LinkList L)//打印链表
{
	LinkList p = L->next;//重置工作指针
	while (p != L)//遍历整个链表
	{
		cout <<"表中剩余所有节点的编号为:" << p->data.id << " " << "姓名为:" << p->data.name << " " << "性别为:";
		if ((p->data.sex) == 1)cout << "男";
		else cout << "女";
		cout << " " << "年龄为:" << p->data.age << endl;
		p = p->next;
	}
}
void ListDelete(LinkList L,int pos)//删除链表中第pos个节点(节点从1开始)
{
	LinkList p = L; int j = 0;
	while (j<pos-1)//找到第pos个节点的前一个;
	{
		p = p->next; j++;
	}
	LinkList q = p->next; p->next = q->next;
	cout << "被删除的人的编号为:" << q->data.id << endl;
	delete q;
	system("pause");
}
int Length(LinkList L)//求表长
{
	LinkList p = L->next;
	int count = 0;
	while (p != L) { count++; p = p->next; }
	return count;
}
LinkList LocateAdd(LinkList L, string S)//由用户编号找到对应节点的地址
{
	LinkList p = L->next;
	while (p != L&&p->data.id!=S)
	{
		p = p->next;
	}
	return p;
}
这里的LinkList为LNode的指针类型
尤瑟夫主体算法：
void Yusuf(LinkList L,string S,int M,int X)
{
	LinkList begin = LocateAdd(L,S);//开始报数人的地址;
	int count = Length(L);//记录总人数;
	int j = 1;
	while (count != X)//只要count不等于X就一直循环并删除报M的节点
	{
		int m = M-1;
		while (m--)
		{
			if (begin == L)begin = L -> next;//如果begin循环工作指针为头指针了就往后走一位
			begin = begin->next;
			if (begin == L)begin = L->next;//当然如果begin的next指到了L的话会出现严重的错误这时再移动一次即可
		}
		LinkList p = begin; begin = begin->next;//begin从下一个数据开始
		cout << "第" << j << "个被干掉的节点编号为" << p->data.id << endl; j++;
		ListDelete(L, LocateElem(L, p->data.id));//根据id找到元素并删除
		count--;//总人数减一直到剩余X个人为止
	}
	system("cls");
}

3、运行结果展示

3.1读入总人数再依次添加每个人的信息；

3.2依次添加完6个人后打印一开始的链表

3.3输入开始报数的位置、间隔的人数和最后剩余的人数

3.4循环删除节点且程序会自动给出每次删掉的节点

3.5尤瑟夫算法结束后会打印表中剩余的节点

还测试了4、8个人的从不同位置和间隔不同人的报数结果，和预期结果一致；

4、反思

1.C++和C语言最好不要混用，例如不要用malloc为包含string的类申请空间，不然会出现不好预测的错误；

2.边界条件要判断清楚，不然很容易导致头结点被删除的情况，或者是节点添加位置出现异常；

5、源代码

//从键盘中读入人数N以及N个人的编号(int)、姓名、性别和年龄,正向建立带头结点的循环链表;
//输出循环链表各节点的值;
//输入开始报数的人的编号S、间隔的人数M和剩余人数X;
//从1开始向后报数、将报M的人删除,并输出这个人的编号;
//从刚被删除的下一个人开始重复直至剩下X人为止;
//输出剩余的人的编号、姓名、性别和年龄;
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cstring>
#include"Person.h"
#include"LNode.h"

using namespace std;
typedef LNode* LinkList;//将LNode的指针类型重命名为LinkList

LinkList InitList()//建立一个循环链表
{
	LinkList L = new LNode;//在内存中为头节点开辟一段空间
	if (!L)exit(1);
	L->next = L;
	return L;//用返回的方式拿出这段内存
}
int LocateElem(LinkList L, string id)//由id找到pos
{
	int pos = 0;//元素编号从1开始
	LinkList p = L;
	while (p->data.id != id)
	{
		p = p->next; pos++;
	}
	return pos;
}
void DestroyList(LinkList L)//销毁一个链表
{
	LinkList p = L;
	while (p!=L)
	{
		LinkList s = p;
		p = p->next;
		delete s;
	}
	L = NULL;
}
void ListInsert(LinkList L)
{
	LinkList s = new LNode;
	if (!s)exit(1);
	cout << "************************" << endl;
	cout << "请依次输入添加人员的信息:" << endl;//给节点的信息赋值;
	cout << "编号为(编号两两之间不能相同):" << endl; cin >> s->data.id;
	cout << "姓名为:" << endl; cin >> s->data.name;//用malloc分配空间时给名字赋值时会报错,因为malloc不能提供string的构造函数;
	cout << "性别为(1为男0为女):" << endl; cin >> s->data.sex;
	cout << "年龄为:" << endl; cin >> s->data.age;
	cout << "添加成功!" << endl;
	system("pause");
	s->next = L->next;
	L->next = s;//头插法逆向建立链表;
	system("cls");
}
void ListInvert(LinkList L)//链表置逆
{
	LinkList p = L->next;
	L->next = L;//将头指针重置
	while (p != L)//从第一个元素开始依次头插法完成逆序转正序
	{
		LinkList s = new LNode;//将原链表的各个节点重新插入到置逆的链表中;
		s->data.id = p->data.id;
		s->data.name = p->data.name;
		s->data.sex = p->data.sex;
		s->data.age = p->data.age;
		s->next = L->next;
		L->next = s;
		p = p->next;
	}
}
void ListPrint(LinkList L)//打印链表
{
	LinkList p = L->next;//重置工作指针
	while (p != L)//遍历整个链表
	{
		cout <<"表中剩余所有节点的编号为:" << p->data.id << " " << "姓名为:" << p->data.name << " " << "性别为:";
		if ((p->data.sex) == 1)cout << "男";
		else cout << "女";
		cout << " " << "年龄为:" << p->data.age << endl;
		p = p->next;
	}
}
void ListDelete(LinkList L,int pos)//删除链表中第pos个节点(节点从1开始)
{
	LinkList p = L; int j = 0;
	while (j<pos-1)//找到第pos个节点的前一个;
	{
		p = p->next; j++;
	}
	LinkList q = p->next; p->next = q->next;
	cout << "被删除的人的编号为:" << q->data.id << endl;
	delete q;
	system("pause");
}
int Length(LinkList L)//求表长
{
	LinkList p = L->next;
	int count = 0;
	while (p != L) { count++; p = p->next; }
	return count;
}
LinkList LocateAdd(LinkList L, string S)//由用户编号找到对应节点的地址
{
	LinkList p = L->next;
	while (p != L&&p->data.id!=S)
	{
		p = p->next;
	}
	return p;
}
void Yusuf(LinkList L,string S,int M,int X)
{
	LinkList begin = LocateAdd(L,S);//开始报数人的地址;
	int count = Length(L);//记录总人数;
	int j = 1;
	while (count != X)//只要count不等于X就一直循环并删除报M的节点
	{
		int m = M-1;
		while (m--)
		{
			if (begin == L)begin = L -> next;//如果begin循环工作指针为头指针了就往后走一位
			begin = begin->next;
			if (begin == L)begin = L->next;//当然如果begin的next指到了L的话会出现严重的错误这时再移动一次即可
		}
		LinkList p = begin; begin = begin->next;//begin从下一个数据开始
		cout << "第" << j << "个被干掉的节点编号为" << p->data.id << endl; j++;
		ListDelete(L, LocateElem(L, p->data.id));//根据id找到元素并删除
		count--;//总人数减一直到剩余X个人为止
	}
	system("cls");
}
int main()
{
	int N;
	cout << "请输入总人数:" << endl;
	cin >> N;
	LinkList L=InitList();//创建链表
	while (N--)ListInsert(L);
	ListInvert(L);//插入之后完成置逆操作
	ListPrint(L);//输出节点数据
	string S;int M, X;
	cout << "请输入开始报数的人的编号:" << endl; cin >> S; //S为开始报数的人的编号
	cout << "请输入间隔的人数:" << endl; cin >> M; //M为间隔的人数
	cout << "请输入剩余的人数:" << endl; cin >> X; //X为剩余的人数
	Yusuf(L, S, M, X);//执行尤瑟夫算法
	ListPrint(L);//打印剩余的元素
	system("pause");
	DestroyList(L);//释放空间
	return 0;
}

 

qint_coding
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
约瑟夫环问题 数据结构 实验
12-16
数据结构第一章上机实验课题 问题描述如下 编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始人选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从它在顺时针方向的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序
约瑟夫环数据结构实验报告
10-25
约瑟夫环数据结构实验的具体步骤包括源代码
【数据结构实验】约瑟夫环
雨林木风的博客
04-20 1438
分别利用线性表的顺序存储形式和链式存储形式，按照出列的顺序印出各人的编号，包含完整源代码。
约瑟夫环问题
热门推荐
hshopeful
07-20 1万+
约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。 C代码如下： #include #include #include typedef struct _node { struct _node* next;
数据结构实验：约瑟夫环问题
最新发布
cccccczl0131的博客
12-20 1246
首先刚开始的次序为1，2，3，...，7，8。从第一个人开始遍历，数到m，也就是第m个人就出去，先打印出列人的序号，再把这个结点从表中删除，继续遍历，继续找到下一个出列的人打印序号。报max的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。然后我们进入约瑟夫环问题，成员依次报数，每当达到报数上限时，先覆盖上限值，再在循环单链表中删除当前节点，继续新一轮的报数，知道链表中剩下最后一个储存数据的结点。printf("请输入m的值\n");
数据结构实验约瑟夫环问题实验报告
11-18
数据结构实验约瑟夫环问题实验报告 本实验报告旨在解决约瑟夫环问题，并提供了 experiment 报告的详细内容。 一、实验目的及要求 实验目的：设有编号为 1，2，...，n 的 n(n>0)个人围成一个圈，每个人持有一个...
数据结构上机报告——约瑟夫环
09-07
一份数据结构上机关于约瑟夫环的上机报告，word版本。
数据结构c语言版约瑟夫环.zip
04-12
约瑟夫（Joseph）问题的一种描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈，没人持有一个密码（正整数）。...数据结构c语言版1.2约瑟夫环实验报告，有手动输入和随机生成两种，拓展部分用了数组来实现。
数据结构实验《约瑟夫环问题》
11-19
数据结构实验《约瑟夫环问题》 #include"iostream.h" #define N 100 typedef struct node//采用数据类型定义 { int number; struct node *next; }Lnode,*LinkList; LinkList InitRingList(int n)//建立一个单循环...
数据结构报告——约瑟夫环问题
06-09
我在2010学年用c++写的约瑟夫环，全是用类封装过的，代码写的还可以，报告自我感觉一般，所以只是作为资源交流之用。忘了去掉名字了，就当自我介绍吧
约瑟夫环实验报告
11-01
【问题描述】编号为1，2，···，n的n个人围坐在一圆桌旁。从第一个人开始报数，报到一个预先约定的正整数m时，停止报数，报m的人退席，下一个人又重新从1开始报数，依此重复，直至所有的人都退席。编一程序输出他们退席的编号序列。 【要求】采用顺序结构或链式结构完成以上程序。 【提示】用不带表头结点的循环单链表表示围成圆圈的n个人；建立此循环单链表；某人离席相当于删除一个结点要正确设置程序中循环终止的条件和删除结点时指针的修改变化。 【测试数据】 m=20，n=7，退席的人的编号依次为6，1，7，5，3，2，4
约瑟夫环实习数据报告
03-19
内容非常详尽，有ADT描述，程序具体模块化分，详细程序设计，试验测试结果用截图表示，还有课后小结。特别好
数据结构报告-约瑟夫环问题
05-02
本实验为数据结构实验用循环链表编程，实验报告内容很全，代码有详细的注释。及运行结果
约瑟夫环代码及实验！！
10-18
约瑟夫环~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
数据结构与算法 实验报告一 约瑟夫环（单循环链表）
weixin_64234293的博客
04-02 3508
实验内容： 约瑟夫环求解。 编号为1，2，....,N的N个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。一开始任选一个正整数作为报数上限值M,从第一个人开始按顺时针方向自1开始顺序报数,报到M时停止报数。报M的人出列,将他的密码作为新的M值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。试设计一个程序求出出列顺序。利用单向循环链表存储结构模拟此过程,按照出列的顺序打印出每个人的编号。 测试数据示例： 若M的初值为20;N=7;7个人 的密码依次为:3,1,.
约瑟夫环实现实验报告（完成代码+实验截图）
m0_62645012的博客
12-15 5399
约瑟夫环手打实现，十分有趣
九度OJ 题目1188：约瑟夫环
落日小屋
02-14 2031
题目1188：约瑟夫环 时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：689 解决：303 题目描述：     N个人围成一圈顺序编号，从1号开始按1、2、3......顺序报数，报p者退出圈外，其余的人再从1、2、3开始报数，报p的人再退出圈外，以此类推。     请按退出顺序输出每个退出人的原序号。 输入：
【数据结构与算法】约瑟夫环（C/C++）
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-01 4904
约瑟夫问题的一种描述是：编号为1,2,...,n的n个人按顺时针方向围坐一圈，每人持有一个密码(正整数)。一开始任选一个正整数作为报数上限值m，从第一个人开始。按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计程序求出出列顺序。
约瑟夫环
laoleeka的博客
10-29 289
简单约瑟夫环的实现，主要使用链表 这应该是大多数在校生的第一个数据结构吧
数据结构实验约瑟夫环
11-21
约瑟夫环是一个经典的问题，它的基本形式是：n个人围成一圈，从第一个人开始报数，报到m的人出圈，剩下的人继续从1开始报数，直到所有人出圈为止。在数据结构中，可以使用链表或数组来实现约瑟夫环。 以下是使用链表实现约瑟夫环的示例代码： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node, *LinkList; void createList(LinkList *L, int n) { *L = (LinkList) malloc(sizeof(Node)); (*L)->next = *L; Node *p = *L; for (int i = 1; i <= n; i++) { Node *newNode = (Node *) malloc(sizeof(Node)); newNode->data = i; newNode->next = p->next; p->next = newNode; p = p->next; } } void josephus(LinkList L, int m) { Node *p = L; while (p->next != p) { for (int i = 1; i < m; i++) { p = p->next; } Node *q = p->next; printf("%d ", q->data); p->next = q->next; free(q); } printf("%d\n", p->data); } int main() { int n = 7, m = 3; LinkList L; createList(&L, n); josephus(L, m); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值