数据结构 约瑟夫环问题

最新推荐文章于 2023-02-26 10:56:40 发布
原创 最新推荐文章于 2023-02-26 10:56:40 发布 · 436 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #循环链表 #约瑟夫

本文介绍了一种企业级循环链表的实现方法，通过将链表的数据类型和链表结构进行解耦，使得在业务变化时无需重新编写链表。文章详细展示了链表的各种操作方法，包括初始化、插入、删除等，并通过约瑟夫环问题演示了其应用。 
#include <stdio.h>
#include <stdlib.h>
/**
*企业链表，与常规链表不同是，链表数据类型和链表进行分离(解耦)
*当业务发生变化，需要新的数据类型时，不需要写新的链表
*/

//与自定义数据类型node进行对应
typedef struct Node{
	struct Node *next;
}STNode_def;

//链表头结点
typedef struct CicLinklist{
	struct Node head;
	int size;				//包含链表大小因为获取链表大小时不需要每次遍历(链表结点数量过多会消耗时间)
}STCicLinklist_def;


#define SUCCESS 0
#define FAILURE -1

//typedef void (*PRINTLIST)(STNode_def* node);
//typedef int (*CICLINKLIST_COMPARE)(STNode_def*, STNode_def*);
//循环链表初始化
STCicLinklist_def* ciclinklist_init()
{
	STCicLinklist_def* list_ptr = (STCicLinklist_def*)malloc(sizeof(STCicLinklist_def));
	list_ptr->head.next = &(list_ptr->head);
	list_ptr->size = 0;

	return list_ptr;
}

//尾插入
int ciclinklist_push_back(STCicLinklist_def* list_ptr, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	
	//辅助结点指针，头结点指针赋值给赋值结点
	STNode_def* p = &(list_ptr->head);
	while (p->next != &(list_ptr->head))
	{
		p = p->next;
	}

	p->next = data;
	data->next = &(list_ptr->head);
	
	list_ptr->size++;
	return SUCCESS;
}


//头插入
int ciclinklist_push_front(STCicLinklist_def* list_ptr, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	
	data->next = list_ptr->head.next;
	list_ptr->head.next = data;
	
	list_ptr->size++;
	
	return SUCCESS;
}


//根据pos位置进行插入
int ciclinklist_push_bypos(STCicLinklist_def* list_ptr, int pos, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	if (pos < 0 || pos >= list_ptr->size)
	{
	    pos = list_ptr->size;   //pos位置不合法时，默认尾部插入  
	    printf("pos=%d\n", pos);  
	}
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	
	//指定位置插入节点，需找出前驱结点
	while (p->next != &(list_ptr->head) && i<pos) 
	{
        p = p->next;
        i++;
    }
    data->next = p->next;
    p->next = data;
    
    list_ptr->size++;
    
	return SUCCESS;
}


//尾删
int ciclinklist_pop_back(STCicLinklist_def* list_ptr)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	if (list_ptr->size == 0)
	{
	    return FAILURE;
	}
	//辅助结点指针，需找到删除结点的前驱结点
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	while (p->next != &(list_ptr->head) && i < list_ptr->size-1)
	{
		p = p->next;
		i++;
	}

	p->next = &(list_ptr->head);
	list_ptr->size--;
	
	return SUCCESS;
}


//头删
int ciclinklist_pop_front(STCicLinklist_def* list_ptr)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	if (list_ptr->size == 0)
	{
	    return FAILURE;
	}
	//辅助结点指针，需找到删除结点的前驱结点
	list_ptr->head.next = list_ptr->head.next->next;
	list_ptr->size--;
	
	return SUCCESS;
}


//指定pos位置删除
int ciclinklist_pop_bypos(STCicLinklist_def* list_ptr, int pos)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	
	//空链表删除也报错
	if (pos < 0 || pos > list_ptr->size -1 || list_ptr->size == 0)
	{
	    return FAILURE;
	}
	
	//辅助结点指针，需找到删除结点的前驱结点
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	while (p->next != &(list_ptr->head) && i < pos)
	{
		p = p->next;
		i++;
	}
    
	p->next = p->next->next;
	list_ptr->size--;
	
	return SUCCESS;
}



//根据值进行遍历查找比较删除
int ciclinklist_pop_byvalue(STCicLinklist_def* list_ptr, STNode_def* value, int (*CICLINKLIST_COMPARE)(STNode_def*, STNode_def*))
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	
	//空链表删除也报错
	if (list_ptr->size == 0)
	{
	    return FAILURE;
	}
	
	//辅助结点指针，需找到删除结点的前驱结点
	STNode_def* p = &(list_ptr->head);
	while (p->next != &(list_ptr->head))
	{
	    if (CICLINKLIST_COMPARE(p->next, value))
		{
		    p->next = p->next->next;
		    list_ptr->size--;
		    break;
		}
		p = p->next;
	}

	return SUCCESS;
}
//遍历链表
void ciclinklist_print(STCicLinklist_def* list_ptr, void (*PRINTLIST)(STNode_def*))
{
    if (list_ptr == NULL || PRINTLIST == NULL)
    {
        return;
    }
    STNode_def* p = &(list_ptr->head);
    while (p->next != &(list_ptr->head)) 
    {
        p = p->next;
        PRINTLIST(p);
    }
}

/**约瑟夫环问题，是一个经典的循环链表问题，
*题意是：已知 n 个人（以编号1，2，3，…，n分别表示）围坐在一张圆桌周围，
*从编号为 k 的人开始顺时针报数，数到 m 的那个人出列；
*他的下一个人又从 1 还是顺时针开始报数，数到 m 的那个人又出列；
*依次重复下去，要求找到最后出列的那个人，假设m为3
*/
void ciclinklist_ysfprint(STCicLinklist_def* list_ptr, void (*PRINTLIST)(STNode_def*), int (*CICLINKLIST_COMPARE)(STNode_def*, STNode_def*))
{
    if (list_ptr == NULL || PRINTLIST == NULL)
    {
        return;
    }
    
    int cnt = 1;
    STNode_def* p = list_ptr->head.next;
    while (list_ptr->size > 1) 
    {
        if (list_ptr->size == 1)
        {
            break;
        }
        if (p == &(list_ptr->head))
        {
            p = list_ptr->head.next;
        }
        //删除结点需要找出前一个结点
        if (cnt == 2)
        {
            STNode_def* pnext = p->next;
            if (pnext == &(list_ptr->head))
            {
                pnext = list_ptr->head.next;
            }
            PRINTLIST(pnext);
            ciclinklist_pop_byvalue(list_ptr, pnext, CICLINKLIST_COMPARE);
            cnt = 0;
        }
        p = p->next;
        cnt++;
    }

}
//销毁链表
void list_destory(STCicLinklist_def* list_ptr)
{
    if (list_ptr == NULL)
    {
        return;
    }
    
    free(list_ptr);
    list_ptr = NULL;
}
//自定义数据类型
typedef struct Student{
    STNode_def node;
    int num;
}STStudent_def;


//自定义数据输出函数
void student_info_print(STStudent_def* node)
{
    printf("num=%d\n", node->num);
}

int student_compare(STNode_def* var1, STNode_def* var2)
{
    STStudent_def* p1 = (STStudent_def*)var1;
    STStudent_def* p2 = (STStudent_def*)var2;
    if (p1->num == p2->num)
    {
        printf("num[%d] delete\n", p2->num);
        return 1;
    }
    
    return 0;
}
int main()
{
    STStudent_def p1;
    STStudent_def p2;
    STStudent_def p3;
    STStudent_def p4;
    STStudent_def p5;
    STStudent_def p6;
    STStudent_def p7;
    STStudent_def p8;


    p1.num = 1;
    p2.num = 2;
    p3.num = 3;
    p4.num = 4;
    p5.num = 5;
    p6.num = 6;
    p7.num = 7;
    p8.num = 8;
    STCicLinklist_def * list_ptr = ciclinklist_init();
    ciclinklist_push_back(list_ptr, &p1);
    ciclinklist_push_back(list_ptr, &p2);
    ciclinklist_push_back(list_ptr, &p3);
    ciclinklist_push_back(list_ptr, &p4);
    ciclinklist_push_back(list_ptr, &p5);
    ciclinklist_push_back(list_ptr, &p6);
    ciclinklist_push_back(list_ptr, &p7);
    ciclinklist_push_back(list_ptr, &p8);
    
    ciclinklist_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);

    ciclinklist_ysfprint(list_ptr, student_info_print, student_compare);
    
    ciclinklist_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    list_destory(list_ptr);
	return 0;
}
数据结构作业1-约瑟夫环问题
StevenDouglas的博客
05-06 1416
数据结构课作业，上网找了一圈发现没有和我们题一样的。自己写一个分享给有需要的同学。 题目如下： 约瑟夫（Josephus）环问题：编号为1,2,3,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一人开始重新从1报数，如此...
数据结构约瑟夫环问题，链表环的问题。
qq_51344334的博客
08-18 251
一.约瑟夫环问题 使用单链表解决约瑟夫环问题，基本思想： 设置一个计数器count和工作指针p和q，当计数器累加到m时，删除结点p。为了能够让计数器从1开始计数，将采用尾指针指示的循环单链表，q指向p结点的前驱结点。 #include<iostream> using namespace std; struct Node //定义约瑟夫环的结点Node { int data; struct Node *next; }; class JosephRing { public: JosephRing
约瑟夫环问题（数据结构课程设计报告+源代码）
12-11
数据结构课程设计报告+源代码 用链表实现约瑟夫环
数据结构约瑟夫环问题
03-28
数据结构链表求解约瑟夫环，我亲手所写，搞定数据结构不是梦。
数据结构---约瑟夫环问题
qq_40955824的博客
07-22 855
单向循环链表 单向循环链表： 在单向链表中，头指针是相当重要的，因为单向链表的操作都需要头指针，所以如果头指针丢失或者破坏，那么整个链表都会遗失，并且浪费链表内存空间。 构建一个单向的环形链表思路 先创建第一个节点, 让 first 指向该节点，并形成环形 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可. 遍历环形链表思路 先让一个辅助指针(变量) cur，指向he...
数据结构--约瑟夫环问题
赵铁蛋的博客
08-14 1497
1.问题描述
数据结构约瑟夫环问题.doc
09-22
在数据结构领域，解决约瑟夫环问题通常采用循环链表作为基础数据结构。循环链表是一种特殊的链表，最后一个节点的指针指向第一个节点，形成一个环状结构，非常适合用于模拟此类环绕排列的问题。 实验的基本要求是...
数据结构：约瑟夫环问题代码
qq_45611259的博客
05-13 4334
原问题 解决问题的代码 #include<stdio.h> #include<stdlib.h> typedef int Status; #define ERROR 0; #define OK 1; typedef struct node { int id;//编号 int password;//密码 struct node *next; }node,*LinkList; /* 用带头结点的尾插法创建有n个结点的循环链表，并返回尾结点 */ LinkLis
数据结构值约瑟夫环问题
李小俊的专栏
04-07 719
注意以下代码略去package和import语句 Person类来描述每个人及其手中的密码，作为线性表中的元素类型 public class Person { private String name; //用老几来表示 private int pwd; //每个人手中持有的密码，作为下次的报数值 public Person(String name,int pw
解题笔记（10）——约瑟夫环问题
热门推荐
wuzhekai的专栏
07-24 5万+
问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。           思路：容易想到的就是用环链表来做，构建一个环链表，每个结点的编号为0, 1, ...... n-1。每次从当前位置向前移动m-1步，然后删除
数据结构 约瑟夫环－密码问题
10-12
密码问题 #include "utility.h" #include "simple_circ_lk_list.h" #include int main() { SimpleCircLinkList l; int sum,k=0; int code; int i,e; int position; int count=1; int a,b; Node *temp=NULL; Node *nexttemp; cout<>sum; while (sum<=0){cout<<"error!"<<endl;cout<0): ";cin>>sum;} { cout<<"error‚"<<endl; while(k==0) { for (i=1;i>e;
数据结构与算法----约瑟夫环问题
05-09
约瑟夫环问题的代码实现，用的是java，由图像化展示界面
约瑟夫环问题 数据结构 实验
12-16
数据结构第一章上机实验课题 问题描述如下 编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始人选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从它在顺时针方向的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序
数据结构—约瑟夫环问题(C语言版)
m0_73463638的博客
02-26 2万+
数据结构—约瑟夫环问题(C语言版)
约瑟夫环问题数据结构（线性表）
linkk_k的博客
10-20 1497
约瑟夫环问题(线性表) 任给正整数N和K，按下述方法可以得到1,2, …,n的一个置换，将数字1,2,…,n环形排列，按顺时针方向自1开始报数，报到K时输出该位置上的数字，并使其出列。然后从他在顺时针方向的下一个数字继续报数，如此下去，直到所有的数字全部出列为止。例如N=10，K=3，则正确的出列顺序应为3，6，9，2，7，1，8，5，10，4。 以下： #include<iostream&...
数据结构之约瑟夫环问题
magic_faker的博客
02-20 749
有 n 个人，按 1 到 n 编号，要求从第 s 个人开始循环报数，报到 m 时，此人出列，再从下一个人开始报 m个数，直到所有人出列。给出 n 个人出列的顺序。 #include "stdio.h" typedef struct node{ int number; /*编号*/ struct node * next; }LNode,*LinkList; void CreatJoseph...
数据结构与算法 约瑟夫环问题 Josephus问题
Shuffle_L的博客
05-29 1118
问题描述：有 n 个人围成一个圈，从第 k 个人开始从 1 开始一个人一个人的报数，数到第 m 个人，让他出列；然后从出列的下一个人重新开始报数，数到第 m 个人，再让他出列，……，如此反复直到圆圈中只剩一个人为止，请模拟这一工作过程。即已知：人数 n，初始编号 k，出列值 m，而且每次的 m 值都不一样；输出整个过程中，出列编号的序列 L，以及最后留下的元素位置。建立一个无头结点的单向循环链表，...
Java数据结构之约瑟夫环问题
qq_43610675的博客
01-31 269
约瑟夫环问题： 设编号为1，2，3…n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的人出列，它的下一位又开始从1开始报数，数到m的那个人又出列，以此类推直到所有人出列为止，由此产生一个出队列编号的序列 解决思路： 用一个环形单链表解决，需要两根指针first和helper，first指向第一个结点，而且辅助指针helper，事先指向环形链表最后的结点，报数前...
数据结构约瑟夫环问题c语言
最新发布
03-08
### C语言实现约瑟夫环问题的数据结构 #### 链表节点定义 为了实现约瑟夫环问题，首先需要定义一个链表节点结构体来表示每个人。这个结构体包含两个成员：`data`用于存储人的编号；`next`是指向下一个节点的指针。 ```c struct Node { int data; // 数据域，代表人的编号 struct Node* next; // 指针域，指向下一个结点 }; ``` 此部分描述了如何创建单个个体作为循环列表中的元素[^1]。 #### 创建并初始化链表 接下来要构建一个完整的循环链表，即让最后一个人指向第一个人形成闭环。这里通过分配内存给新的节点并将它们连接起来完成这一过程： ```c void createJosephusList(struct Node** head, int n) { *head = NULL; if (n <= 0) return; struct Node* pNewNode = NULL; struct Node* pLastNode = NULL; for(int i=1;i<=n;++i){ pNewNode=(struct Node*)malloc(sizeof(struct Node)); pNewNode->data=i; pNewNode->next=NULL; if(*head==NULL){ // 如果是第一个节点，则设置头指针 *head=pNewNode; pLastNode=*head; }else{ // 否则将其加入到当前链表末尾 pLastNode->next=pNewNode; pLastNode=pNewNode; } if(i==n) // 当达到指定人数时闭合链表 pLastNode->next=*head; } } ``` 这段代码展示了怎样建立初始状态下的参与者队伍，并确保他们组成一个封闭式的圈子等待游戏开始。 #### 执行约瑟夫环算法 有了上述准备之后就可以编写执行实际逻辑的部分——根据设定好的规则逐一轮流淘汰直至剩下最后一人为止: ```c int josephusProblem(struct Node* head,int m){ struct Node* temp=head,*prev=NULL; while(temp->next!=temp){ // 只剩一人时结束循环 for(int count=1;count<m;count++){ prev=temp; temp=temp->next; } printf("Person %d is out.\n",temp->data); prev->next=temp->next; // 删除被淘汰者所在的节点 free(temp); // 释放被删除节点所占空间 temp=prev->next; // 更新临时指针继续遍历剩余人员 } int survivor=temp->data; // 记录幸存者的编号 free(temp); // 清理最后一个节点 return survivor; } ``` 以上程序片段解释了具体的操作流程以及每一步骤背后的原理[^2]。 #### 主函数调用示例 最后，在主函数中调用这些辅助方法即可测试整个解决方案的功能性和正确性： ```c #include <stdio.h> #include <stdlib.h> // ... 上述定义和函数 ... int main(){ int n,m,survivor; scanf("%d%d",&n,&m); struct Node* head; createJosephusList(&head,n); survivor=josephusProblem(head,m); printf("The last person alive is Person %d\n",survivor); return 0; } ``` 该段落提供了完整的工作实例，使得读者能够理解从输入参数到最后输出结果的整体运作方式[^3]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值