循环链表解决约瑟夫环问题

最新推荐文章于 2021-12-18 22:14:10 发布
最新推荐文章于 2021-12-18 22:14:10 发布
阅读量6.9k 收藏 16
点赞数 8
文章标签： 循环链表 单链表 约瑟夫环问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jw903/article/details/38962587
版权

约瑟夫环是一个经典的数学的应用问题：已知N个人（以编号1，2，3...N分别表示）围坐在一张圆桌周围。从编号为1的人开始报数，数到M的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

这里使用循环单链表解决约瑟夫环问题，该循环单链表不带哑元头结点，相比于带有哑元头结点的循环单链表，对不带带有哑元头结点的循环单链表的相关操作，包括插入，删除，销毁等操作相对麻烦一点，稍不注意可能就有bug,所以一定要细心才对。

下面的求解约瑟夫问题的核心算法思想来自于《算法：C语言实现》这本书，代码的重点部分已经标注，当然有时间还会对代码优化。假设已经建立长度为N的链表。

/*---------------------------约瑟夫问题核心代码：--------------------------------*/
	ListNode *p=head;
	while(p->next!=head)//循环的目的是让p指向链表的尾节点
	{
		p=p->next;
	}
	while(p!=p->next)//循环开始时，p指向链表的尾节点
	{
		for(i=1;i<M;i++)
			p=p->next;

		ListNode *targetnode=p->next;
		cout<<targetnode->item<<"出局"<<endl;
		p->next=p->next->next;
		free(targetnode);
	}
	cout<<p->item<<"胜出"<<endl;
	free(p);

不带哑元头结点的一些基本操作：

链表节点类型

typedef struct Node
{
	int item;
	struct Node *next;
}ListNode,*List;

1.插入——头插法

List InsertNodeToFront(List head,int data)//------------头插法
{
	ListNode *newnode=(List)malloc(sizeof(ListNode));//创建新节点
	assert(newnode);
	newnode->item=data;
	newnode->next=NULL;

	if(head==NULL)
	{
		head=newnode;
		head->next=head;
	}
	else
	{
	/*--------------------------------------------------*/
		ListNode *p=head;//由于是头插法，插入一个节点，表头指针head的指向就会改变
		while(p->next!=head)//由于是循环链表，链表的尾节点的next指针指向也会改变，
		{                   //需要指向新的表头，因此，需要在改变表头前，将尾节点找到
			p=p->next;
		}
	/*---------------------------------------------------*/
		newnode->next=head;
	    head=newnode;
		p->next=head;
	}
	return head;
}

2.插入——尾插法 

List InsertNodeToTail(List head,int data)//--------尾插法
{
	ListNode *newnode=(List)malloc(sizeof(ListNode));//创建新节点
	assert(newnode);
	newnode->item=data;
	newnode->next=NULL;

	if(head==NULL)
	{
		head=newnode;
		head->next=head;//
	}
	else
	{
		ListNode *p=head;
	    while(p->next!=head)
		{
			p=p->next;
		}
		p->next=newnode;
		newnode->next=head;//
	}
	return head;
}

3.查找： 

bool FindNode(List head,int data)//查找链表中含有某元素的节点是否存在
{
	if(head==NULL)
	{
		cout<<"the Dlist is NULL"<<endl;
		return false;
	}
	ListNode *p=head;
	do
	{
		if(p->item==data)
			return true;
		p=p->next;
	}while(p!=head);
	return false;
}

4.删除： 

List DeleteNode(List head,int data)//删除节点
{
	assert(head);
	ListNode *p=head;
	ListNode *pre=NULL;
	for(;p!=head;pre=p,p=p->next)
	{
		if(p->item==data)
			break;
	}
	if(p==head && pre!=NULL)//没找到节点
	{
		cout<<"the target listnode DOESN'T exist!"<<endl;
	}

	if(p==head && pre==NULL)//当表头就是目标节点时
	{
	/*------------------------------------------------------*/
		ListNode *temp=head;
		while(p->next!=temp)//找到链表中的尾节点p,由于链表的头结点要变，所以p->next所指向肯定要变（指向新的头结点）
		{
			p=p->next;
		}
	/*--------------------------------------------------------*/
		head=head->next;
		p->next=head;//尾节点指向新的头结点
		free(temp);
	}
	else  
	{
		ListNode *tmp=p;
		pre->next=p->next;
		free(tmp);
	}
	return head;  
}

5.打印和销毁 

void PrintList(List head)//打印
{
	if(head==NULL)
	{
		cout<<"the list is NULL"<<endl;
		return ;
	}
	ListNode *p=head->next;
	cout<<head->item<<" ";
	while(p!=head)
	{
		cout<<p->item<<" ";
		p=p->next;
	}
	cout<<endl<<endl;
}
void DestroyList(List head)
{
	while(head!=head->next)//释放内存，直到链表中只剩下一个节点
	{
		head=DeleteNode(head,head->item);//从表头开始释放
	}
	cout<<head->item<<endl;
	free(head);//将链表中剩下的最后一个节点进行释放
	head=NULL;
}

完整代码：M=5，N=9，9个人的编号分别为1,2,3,4,5,6,7,8,9,（1处为链表头），从编号1按规则进行约瑟夫选举，最终8胜出 

/***************************************************************************
 *name:jae chia                                                            *
 *date:2014.8.30                                                           *
 *version: 1.0                                                             *
 *********************循环链表解决约瑟夫环问题******************************/

#include<iostream>
#include<cassert>
using namespace std;

typedef struct Node
{
	int item;
	struct Node *next;
}ListNode,*List;
List InsertNodeToTail(List head,int data)//--------尾插法
{
	ListNode *newnode=(List)malloc(sizeof(ListNode));//创建新节点
	assert(newnode);
	newnode->item=data;
	newnode->next=NULL;

	if(head==NULL)
	{
		head=newnode;
		head->next=head;//
	}
	else
	{
		ListNode *p=head;
	    while(p->next!=head)
		{
			p=p->next;
		}
		p->next=newnode;
		newnode->next=head;//
	}
	return head;
}
List InsertNodeToFront(List head,int data)//------------头插法
{
	ListNode *newnode=(List)malloc(sizeof(ListNode));//创建新节点
	assert(newnode);
	newnode->item=data;
	newnode->next=NULL;

	if(head==NULL)
	{
		head=newnode;
		head->next=head;
	}
	else
	{
	/*--------------------------------------------------*/
		ListNode *p=head;//由于是头插法，插入一个节点，表头指针head的指向就会改变
		while(p->next!=head)//由于是循环链表，链表的尾节点的next指针指向也会改变，
		{                   //需要指向新的表头，因此，需要在改变表头前，将尾节点找到
			p=p->next;
		}
	/*---------------------------------------------------*/
		newnode->next=head;
	    head=newnode;
		p->next=head;
	}
	return head;
}
bool FindNode(List head,int data)//查找链表中含有某元素的节点是否存在
{
	if(head==NULL)
	{
		cout<<"the Dlist is NULL"<<endl;
		return false;
	}
	ListNode *p=head;
	do
	{
		if(p->item==data)
			return true;
		p=p->next;
	}while(p!=head);
	return false;
}
List DeleteNode(List head,int data)//删除节点
{
	assert(head);
	ListNode *p=head;
	ListNode *pre=NULL;
	for(;p!=head;pre=p,p=p->next)
	{
		if(p->item==data)
			break;
	}
	if(p==head && pre!=NULL)//没找到节点
	{
		cout<<"the target listnode DOESN'T exist!"<<endl;
	}

	if(p==head && pre==NULL)//当表头就是目标节点时
	{
	/*------------------------------------------------------*/
		ListNode *temp=head;
		while(p->next!=temp)//找到链表中的尾节点p,由于链表的头结点要变，所以p->next所指向肯定要变（指向新的头结点）
		{
			p=p->next;
		}
	/*--------------------------------------------------------*/
		head=head->next;
		p->next=head;//尾节点指向新的头结点
		free(temp);
	}
	else  
	{
		ListNode *tmp=p;
		pre->next=p->next;
		free(tmp);
	}
	return head;  
}
void PrintList(List head)//打印
{
	if(head==NULL)
	{
		cout<<"the list is NULL"<<endl;
		return ;
	}
	ListNode *p=head->next;
	cout<<head->item<<" ";
	while(p!=head)
	{
		cout<<p->item<<" ";
		p=p->next;
	}
	cout<<endl<<endl;
}
void DestroyList(List head)
{
	while(head!=head->next)//释放内存，直到链表中只剩下一个节点
	{
		head=DeleteNode(head,head->item);//从表头开始释放
	}
	cout<<head->item<<endl;
	free(head);//将链表中剩下的最后一个节点进行释放
	head=NULL;
}

void JosephRingTest1()
{
	int M,N;
	int a;//编号
	cout<<"input M（规则） and N(人数）:"<<endl;
	cin>>M>>N;
	List head=NULL;
	int i;	
	for(i=0;i<N;i++)
	{
		cin>>a;
		head=InsertNodeToTail(head,a);//尾插
	}
	cout<<"初始化后的链表:"<<endl;;
	PrintList(head);
	/*---------------------------约瑟夫问题核心代码：--------------------------------*/
	ListNode *p=head;
	while(p->next!=head)//循环的目的是让p指向链表的尾节点
	{
		p=p->next;
	}
	while(p!=p->next)//循环开始时，p指向链表的尾节点
	{
		for(i=1;i<M;i++)
			p=p->next;

		ListNode *targetnode=p->next;
		cout<<targetnode->item<<"出局"<<endl;
		p->next=p->next->next;
		free(targetnode);
	}
	cout<<p->item<<"胜出"<<endl;
	free(p);
	/*---------------------------------------------------------------------------------*/
}
int main(void)
{
	JosephRingTest1();
}


运行：





jw903
关注
[C & C++]利用循环链表解决约瑟夫环问题
自觉 觉他
01-31 3603
约瑟夫环 /C /C++ /循环链表
[C&C++]利用循环链表解决约瑟夫环问题.rar
01-31
分别基于C和C++利用循环链表的数据结构解决约瑟夫环问题 注释详细，包含了Visual Studio 2017 Professional的工程文件，可以直接运行 包含了C语言实现和C++实现两个文件
循环链表实现约瑟夫环问题
11-06
循环链表实现约瑟夫环问题 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
用循环链表解决约瑟夫环问题
dongchuan5097的博客
06-11 253
约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。 下面我们用循环列表模拟这个过程： 1 //节点定义与单链表相同，在此省略 2 //use cyclical linked list to s...
C++ 用循环链表解决约瑟夫环问题
difei7767的博客
05-26 972
约瑟夫环问题 已知 n 个人(n>=1)围坐一圆桌周围，从 1 开始顺序编号，从序号为 1 的人开始报数，顺时针数到 m 的那个人出列。下一个人又从 1 开始报数，数到m 的那个人又出列。依此规则重复下去，直到所有人全部出列。请问最后一个出列的人的初始编号。 要求 输入人数 n，所报数 m，输出最后一个人的初始编号。 解决思路 首先因为是圆...
C语言基于循环链表解决约瑟夫环问题的方法示例
01-20
本文实例讲述了C语言基于循环链表解决约瑟夫环问题的方法。分享给大家供大家参考，具体如下： 概述： 约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（以编号1，2，3，…，n分别表示）围坐在一张圆桌...
C++ 中循环链表和约瑟夫环
08-30
C++ 中循环链表和约瑟夫环 C++ 中循环链表和约瑟夫环是一种重要的数据结构和算法思想。循环链表是一种特殊的链表结构，它...了解循环链表和约瑟夫环的实现和算法思想，对于提高编程能力和解决实际问题具有重要的意义。
用循环链表实现约瑟夫环问题
weixin_30700977的博客
07-01 1940
什么是约瑟夫环问题？ 而这实际上就是一个经典的数学问题： 而用一个更生活化的例子来阐述：几个人围坐在一张圆桌上，然后开始数数，数到指定数则淘汰，然后再重1开始数，直到还剩最后一个人则为胜利者。 而具体代码如何来实现呢？ 首先还是基于上次的那个链表进行扩展： 接着构造一个循环链表，为了使代码更加的清晰，这里采用面向对象的方法来进行封装 接下来就是去实现这个add方法...
用循环链表实现的约瑟夫环
03-29
用循环链表的方式实现约瑟夫环，下面是部分代码， typedef struct node { int key; int seatnum; struct node *next; }node,*linklist; void createlist(linklist&l,int n) { l=(linklist)malloc(sizeof(node)); l->next=NULL; linklist q=l; for(int i=0;i<n;i++) { node *p=(linklist)malloc(sizeof(node)); p->seatnum=i+1; int m; cout<<"please input the "<<i+1<<"th key"<<endl; cin>>m; p->key=m; p->next=l->next; q->next=p; q=p; } }
用循环链表求解约瑟夫环问题
hnjzsyjyj的专栏
09-28 2435
【约瑟夫环问题】 模型构建：因为是圆桌问题，使用链表解决的话需要构建循环链表。 出列问题：设计思路是将指向链表的指针移动到需要出列的人的位置，然后根据正常的链表删除进行操作即可。
用循环链表实现约瑟夫环
dizp47129的博客
04-05 193
1 #include <stdio.h> 2 #include <stdlib.h> 3 typedef struct node{ 4 int number; 5 struct node * next; 6 }node; 7 node * initLink(int n){ 8 node * head=(...
用循环链表解决约瑟夫环的问题
qq_42180119的博客
12-18 1054
#include <stdio.h> #include<stdlib.h>//使用malloc所需要的头文件 typedef struct LNode{ int tag; struct LNode *next; int iskill; }LNode,*LinkList; void InitLink(LinkList &L) { L=(LinkList)malloc(sizeof(LNode)); L->next=NULL...
循环链表解决约瑟夫环问题（C++）
qq_58126670的博客
07-14 1966
主体思路：创建一个循环链表，每个节点储存的数据表示他们的位置，每出去一个就删除一个节点，并且将链表大小减一，当链表只剩一个节点时，终止循环 注意的点： 1.因为删除要找上一个节点，所以是m-1 2.因为在本题中只需要输出对应元素就好了，所以不需要更改尾指针，没有必要 #include<bits/stdc++.h> using namespace std; class node { public: node* next; int data; node(int a) { data = a
循环链表--解决约瑟夫环问题
hiluo302的博客
04-19 459
循环链表只是把单链表的最后一个结点指向头结点，本链表增加了一个头结点。#include <stdio.h> #include <stdlib.h>typedef struct Node { int data; struct Node *next; }*Rlist;int errMemory(Rlist p) { if(p==NULL) { printf
使用循环链表解决约瑟夫环问题
约瑟夫环问题，也称为约瑟夫环难题或约瑟夫问题，是一个经典的计算机科学问题，涉及到循环链表的使用和算法设计。在这个问题中，n个人围坐成一圈，每个人持有一个密码（正整数），从第一个人开始按顺时针方向依次报...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值