循环链表实现与约瑟夫问题

最新推荐文章于 2021-04-03 16:33:08 发布
最新推荐文章于 2021-04-03 16:33:08 发布
阅读量279 收藏 1
点赞数 1
分类专栏： C++编程问题集 C++编程练习 文章标签： C++ 循环链表 约瑟夫问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FAKER_0X0/article/details/89874455
版权

循环链表API函数头文件

circlelist.h

#pragma once

typedef void CircleList;

typedef struct _tag_CircleListNode
{
	struct _tag_CircleListNode* next;
}CircleListNode;

CircleList* CircleList_Create();

void CircleList_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

CircleListNode* CircleList_Get(CircleList* list, int pos);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

//将游标重置指向链表中的第一个数据元素
CircleListNode* CircleList_Reset(CircleList* list);

//获取当前游标指向的数据元素
CircleListNode* CircleList_Current(CircleList* list);

//将游标移动指向到链表中的下一个数据元素
CircleListNode* CircleList_Next(CircleList* list);

//直接指定删除链表中的某个数据元素
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);
// 根据元素的值 删除 元素 pk根据元素的位置 删除 元素

circlelist.cpp

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "circlelist.h"

typedef struct _tag_CircleList
{
	int length;
	CircleListNode header;	//链表的头部
	CircleListNode* slider;		//循环链表新增功能：游标
}TCircleList;		//定义一个底层的句柄

CircleList* CircleList_Create()
{
	TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
	memset(ret, 0, sizeof(TCircleList));

	ret->length = 0;
	ret->header.next = NULL;	//链表头部指向的下一个为NULL
	ret->slider = NULL;
	return ret;
}

void CircleList_Destroy(CircleList* list)	//释放内存
{
	if (list != NULL)
	{
		free(list);
		list = NULL;
	}
}

void CircleList_Clear(CircleList* list)	//初始化
{
	TCircleList* sList = NULL;
	if (list == NULL)
	{
		return;
	}
	sList = (TCircleList*)list;
	sList->length = 0;
	sList->header.next = NULL;
	sList->slider = NULL;
}

int CircleList_Length(CircleList* list)
{
	int ret = 0;
	TCircleList* sList = NULL;
	if (list == NULL)
	{
		ret = -1;
		printf("func CircleList_Length() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;
	ret = sList->length;
	return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos)
{
	int i = 0;
	CircleListNode* ret = NULL;
	TCircleList* sList = NULL;
	CircleListNode* current;
	if (list == NULL || pos < 0)
	{
		printf("func CircleList_Get() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;

	current = &(sList->header);
	for (i = 0; i < pos && (current->next != NULL); i++)
	{
		current = current->next;	//跳pos次,让current指向插入位置前节点
	}
	ret = current->next;
	return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
	int ret = 0, i = 0;
	TCircleList* sList = NULL;
	CircleListNode* current;
	CircleListNode* last = NULL;	//第二个辅助指针变量
	if (list == NULL || node == NULL || pos < 0)
	{
		ret = -2;
		printf("func CircleList_Insert() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;
	current = &(sList->header);	
	//和CircleListNode* current=(CircleListNode*)sList一样,因为函数入口地址重叠
	for (i = 0; i < pos && (current->next != NULL); i++)	
	{
		current = current->next;
	}
	//1 让node连接后续链表
	node->next = current->next;	
	//2 让前面的节点连接到新的node结点
	current->next = node;

	//如果插入的是第一个结点，让游标指向它
	if (sList->length == 0)
	{
		sList->slider = node;
	}

	sList->length++;

	//若是头插法，需求出尾部结点；判断是头插法
	//if (current == (CircleListNode*)sList)  //一开始是这里出现了问题，尾结点和头结点没有连起来
	if (current == &(sList->header))
	{
		last = CircleList_Get(sList, sList->length - 1);
		last->next = current->next;		//3 尾结点连接头结点
	}
	return ret;
}

CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
	int i = 0;
	CircleListNode* ret = NULL;
	TCircleList* sList = NULL;
	CircleListNode* current;
	CircleListNode* last = NULL;	//第二个辅助指针变量
	if (list == NULL || pos < 0)
	{
		printf("func CircleList_Delete() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;

	current = &(sList->header);		
	for (i = 0; i < pos && (current->next != NULL); i++)
	{
		current = current->next;	
	}

	//若删除头结点，需求出尾部结点；判断
	//if (current == (CircleListNode*)sList)
	if (current == &(sList->header))
	{
		last = CircleList_Get(list, sList->length - 1);	//求的是删除前的最后结点
	}

	//1 缓存被删除的节点位置
	ret = current->next;
	//2 连接
	current->next = ret->next;
	sList->length--;

	若删除头结点，需求出尾部结点；判断
	//if (current == (CircleListNode*)sList)
	//{
	//	last = CircleList_Get(list, sList->length - 1);
	//}

	//判断没有全部删除完
	if (last != NULL)
	{
		sList->header.next = ret->next;		//这个应该是和2重复的了
		last->next = ret->next;
	}

	//若删除的是游标指向的元素，让游标下移
	if (sList->slider == ret)
	{
		sList->slider = ret->next;
	}

	//全部删除完
	if (sList->length == 0)
	{
		sList->header.next = NULL;
		sList->slider = NULL;
	}
	return ret;
}

//将游标重置指向链表中的第一个数据元素
CircleListNode* CircleList_Reset(CircleList* list)
{
	CircleListNode* ret = NULL;
	TCircleList* sList = NULL;
	if (list == NULL)
	{
		printf("func CircleList_Reset() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;
	sList->slider = sList->header.next;
	ret = sList->slider;
	return ret;
}

//获取当前游标指向的数据元素
CircleListNode* CircleList_Current(CircleList* list)
{
	CircleListNode* ret = NULL;
	TCircleList* sList = NULL;
	if (list == NULL)
	{
		printf("func CircleList_Current() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;
	ret = sList->slider;	//直接返回游标
	return ret;
}

//将游标移动指向到链表中的下一个数据元素
CircleListNode* CircleList_Next(CircleList* list)
{
	CircleListNode* ret = NULL;
	TCircleList* sList = NULL;
	if (list == NULL)
	{
		printf("func CircleList_Next() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;

	//ret = sList->slider;	//直接返回游标
	//sList->slider = ret->next;

	if (sList->slider != NULL)
	{
		ret = sList->slider;	//直接返回游标
		sList->slider = ret->next;
	}

	return ret;
}

//直接指定删除链表中的某个数据元素
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
	int i = 0;
	CircleListNode* ret = NULL;
	TCircleList* sList = NULL;
	CircleListNode* current;
	CircleListNode* last;	//第二个辅助指针变量
	if (list == NULL || node == NULL)
	{
		printf("func CircleList_DeleteNode() err: %d\n", ret);
		return ret;
	}
	sList = (TCircleList*)list;
	current = &(sList->header);

	//遍历
	for (i = 0; i < sList->length; i++)
	{
		if (current->next == node)
		{
			ret = current->next;
			break;
		}
		current = current->next;
	}

	if (ret != NULL)
	{
		CircleList_Delete(sList, i);		//根据位置删除
	}
	return ret;
}

测试框架与约瑟夫问题（m=3）

约瑟夫问题-循环链表典型应用

n 个人围成一个圆圈，首先第 1 个人从 1 开始一个人一个人顺时针报数，报到第 m 个人，令其出列。然后再从下一 个人开始从 1 顺时针报数，报到第 m 个人，再令其出列，…，如此下去，求出列顺序。

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "circlelist.cpp"

typedef struct _Value
{
	CircleListNode circlenode;	
	int v;
}Value;

void main()
{
	int ret = 0, i = 0;
	CircleList* list = NULL;

	Value v1, v2, v3, v4, v5, v6, v7, v8;
	v1.v = 1, v2.v = 2, v3.v = 3, v4.v = 4;
	v5.v = 5, v6.v = 6, v7.v = 7, v8.v = 8;

	list = CircleList_Create();//创建线性表
	if (list == NULL)
	{
		ret = -3;
		printf("func CircleList_Create() ret:%d \n", ret);
		return;
	}

	ret = CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v5, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v6, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v7, CircleList_Length(list));	//尾插法
	ret = CircleList_Insert(list, (CircleListNode*)&v8, CircleList_Length(list));	//尾插法

	//使用游标来遍历
	for (i = 0; i < CircleList_Length(list); i++)
	{
		Value* pv = (Value*)CircleList_Next(list);	//一开始的游标值不应该为NULL？
		printf("pv->v: %d\n", pv->v);
	}
	CircleList_Reset(list);	//重置游标

	//此处用来判断出现 pv 是 nullptr 现象的原因，所以上面一开始应该遍历2遍看是不是循环链表
	//Value* pv = NULL;
	//for (i = 0; i < 8; i++)		
	//{
	//	CircleList_Next(list);
	//}
	//pv = (Value*)CircleList_Current(list);
	//printf("pv->v: %d\n", pv->v);	//pv 是 nullptr，说明尾端的next没有指向头部


	//删除元素
	printf("\n约瑟夫问题输出：\n");
	while (CircleList_Length(list) > 0)	
	{
		Value* pv = NULL;

		for (i = 1; i < 3; i++)		//实现约瑟夫问题 从1数到3，令3出列
		{
			CircleList_Next(list);
		}
		pv = (Value*)CircleList_Current(list);

		printf("pv->v: %d\n", pv->v);	//pv 是 nullptr
		CircleList_DeleteNode(list, (CircleListNode*)pv);
	}

	CircleList_Destroy(list);

	system("pause");
}

经验教训：

  1. 一开始测试时应该先遍历2遍证明其是否是循环链表。
  2. 教程里虽然说  current = &(sList->header)  和  CircleListNode* current=(CircleListNode*)sList 一样,因为函数入口地址重叠；但是程序上使用时应该是不要交叉混用，开始赋值和作判断条件使用时应该统一用 current = &(sList->header) 或另一个。
  3. 调试的时候真的要耐心，一步一步的来，不要着急，细心地去发现问题、理解问题并解决问题。
czopg
关注
专栏目录
[数据结构]利用循环链表实现约瑟夫问题
weixin_43717520的博客
04-04 338
约瑟夫环 求出节点销毁顺序
循环链表实现约瑟夫问题
bingboygogo的博客
05-06 3726
## 循环链表实现约瑟夫问题 ## 约瑟夫问题，这是一个事关生命的问题。传说有一天，39个犹太人躲避战乱逃到了一个洞里，洞里还有约瑟夫和他的一个朋友。犹太人呢宁死不屈，为了不让敌人抓住，于是发明了一个死亡游戏。犹太人一致决定，41个人围成一个圈，从第一个人开始数数，当数到3的那个人呢那个人就刺自己一下，把自己给杀了。比如第1个人开始数数，第3个数到3就自杀，接着第4个开始数1，第6个数到3就自杀……
循环链表解决约瑟夫环问题
weixin_34357928的博客
10-10 170
　　约瑟夫环问题可以简单的使用数组的方式实现，但是现在我使用循环链表的方法来实现，因为上午看到一道面试题规定使用循环链表解决约瑟夫环问题。 　　什么是约瑟夫环？ 　　“约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部...
约瑟夫问题（循环链表实现）
痞子晶的博客
09-01 769
刚刚写好，原理很简单，重点是链表的建立和节点的删除，注意：要养成删除的节点后，释放申请的内存的好习惯：） 代码如下： /*约瑟夫环：n个人坐一圈，从1到n给每个人编号。从m个人开始报数，数到第k个人，让他出局。 然后从出局后下一个人开始报数，同样是第k个人，再让他出局，如此的反复，直到剩下最后一人。 问题求剩下一个人编号是多少？（链表实现）*/ #include #include
Java采用循环链表结构求解约瑟夫问题
09-04
在Java中，我们可以使用循环链表数据结构来解决约瑟夫问题。循环链表是一种特殊的链表，它的最后一个节点的next指针指向链表的第一个节点，形成一个闭合的环状结构。下面详细讲解如何实现这个解决方案。 首先，我们...
java编写的循环链表来实现约瑟夫环
11-13
循环链表 实现约瑟夫环 java 自己写的 测试通过 有注释
C数据结构循环链表实现约瑟夫环
01-01
C数据结构循环链表实现约瑟夫环 本文代码均在turbo C 2.0 的环境下运行通过，并得到正确结果，本程序为用循环链表实现约瑟夫环，即有m个人站成一个圆环，从某人（队列第一个）开始报数，约定从某数开始的第n个人出列...
链表-使用C语言实现循环链表应用之解决约瑟夫问题.zip
最新发布
03-13
本项目专注于使用C语言实现循环链表，并将其应用于解决著名的约瑟夫问题。 约瑟夫问题（Josephus Problem）源于一个古老的故事，它涉及到在圆形排列的人群中，按照一定的间隔（通常为3或4）剔除一个人，直到剩下...
单向循环链表实现约瑟夫环.zip
12-05
在提供的"单向循环链表实现约瑟夫环.txt"文件中，可能包含了具体的代码实现或者详细解释，包括节点定义、链表操作（如插入、删除）以及约瑟夫环算法的完整流程。通过阅读和理解这个文件，你可以深入学习如何将理论...
循环链表实现约瑟夫环问题
11-06
循环链表实现约瑟夫环问题 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
利用循环链表实现约瑟夫问题的求解
04-23
利用循环链表实现约瑟夫问题的求解。 约瑟夫问题如下：已知n个人（n>=1）围坐一圆桌周围，从1开始顺序编号。从序号为1的人开始报数，顺时针数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规则重复下去，直到所有人全部出列。请问最后一个出列的人的编号。
约瑟夫环问题通过循环链表实现（c语言版）
11-24
通过循环链表实现约瑟夫环问题，用c语言实现。属于数据结构部分内容
循环链表解决约瑟夫问题
Mekeater的博客
04-03 3339
循环链表解决约瑟夫问题 前言 传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，从而逃过了这场死亡游戏 。 一、循环链表 循环链表，顾名思义
解决约瑟夫问题 -循环链表
GoingJack博客
04-01 288
问题：n个人围成一圈，从某个人开始算step个数，被数到的那个人被淘汰，求最后的胜利者。 typedef struct Node { int val; struct Node *next; struct Node *pre;//用于存放头节点的前一个元素，其实这里我并不是准备定义双向链表 }Node; int Joseph(Node *head,int step,int n) { ...
用循环链表实现约瑟夫问题
pengdonglin137的专栏
02-21 737
约瑟夫问题是个有名的问题：N个人围成一圈，从第K个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=8，M=4, K=3，被杀掉的人的序号为6,2,7,3,5,1,8。   joseph.h   #ifndef __JOSEPH_H__ #define __JOSEPH_H__ #define N 8 //人数为8 #define K 3 //从第3个人开
循环链表实现约瑟夫环问题计数
约瑟夫问题是一种经典的计算机科学问题，源于...总结来说，这段代码实现了一个约瑟夫环问题的基本算法，通过循环链表结构高效地处理了环状结构中淘汰节点的问题，适用于教育和学习编程时演示链表和循环逻辑的应用场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值