约瑟夫环（持有密码版和经典版）【C语言实现】数据结构实验

约瑟夫环（持有密码版和经典版）【C语言实现】

更多相关课程实践代码或者完整项目代码可以前往我的小程序 航筱北同学 查看。

约瑟夫环最开始的是没有密码的，如果有密码的话，约瑟夫和朋友是无法预测最后两个到底是哪两个位置的。

现在，我们改编一下约瑟夫环，改成每个人手中都持有密码。

实验内容

约瑟夫环问题的一种描述是：编号为 1，2，…，n 的 n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值 m，从第一个人开始按顺时针方向自 1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从他在顺时针方向上的下一个人开始重新从 1 报数，如此下去，直到所有人全部出列为止。试设计一个程序求出出列顺序

实验要求

基本要求一：利用单向循环链表模拟此过程，按照出列的顺序印出各人的编号。程序运行后，首先要求用户指定初始报数上限值，然后读取各人的密码。可设n<=30。此题所用的循环链表中不需要头结点，注意空表和非空表的界限。
基本要求二：用顺序表实现该问题。
实现提示
假设 i 为当前数组下标，n 为元素个数，用取模运算%可以实i+1==n 时，i 重新回到下标 0 。即(i+1)%n。
顺序表中的元素存放二个成员，密码和出列标识。也就是说，出列时并不真正删除元素，否则每次需大量移位。只需做出列标识即可。报数统计时跳过已做出列标识的人。第几个人直接和数组下标相对应

测试数据

• （1）：n=7，7 个人的密码依次为：3，1，7，2，4，8，4，首先 m 值为 6
（正确的出列顺序应为 6，1，4，7，2，3，5）。
• （2）： n=9，9 个人的密码依次为：4，3，7，1，5，6，3，8，2，首先 m 值为 4
• （3）：自己任选其它一组测试数据

部分代码【循环链表实现】

typedef struct LNode{
	int id,pwd;				//id用来存储人的序号，pwd用来存储人的密码
	struct LNode *next;         //指向下一个的指针 
}List;
struct LNode *head,*p,*pd;   

/*创建循环链表函数*/
int createLinkList(int n){      
	int i;
    head = (struct LNode *)malloc(sizeof(struct LNode));   //创建一个带头结点的链表
    if(!head) return 0;   //创建不成功，返回0
    p = head;
    for(i = 1 ; i < n ; i++){   
		pd = (struct LNode*)malloc(sizeof(struct LNode));
        if(!pd) return 0;
        p->next = pd;
        p = pd;
	}
	p->next = head;
	pd = head;
	return 0;
}

/*输入密码函数*/
int inputPwd(int n){
	int j,k;
	printf("\n请输入每个人的密码：\n");
	for (j=1;j<=n;j++){
		scanf("%d",&k);
		pd->id = j;
		pd->pwd = k;
		pd = pd->next;
	}
	pd = p;
	return k;
}

/*输出出列序号函数*/
int outList(int m,int n){
	int q,r;
	for(q=1;q<=n;q++){
		for(r=1;r<m;r++) {
			pd = pd->next;
		}
		p = pd->next;
		m = p->pwd;
		printf("%d ",p->id);
		pd->next = p->next;
		free(p);
	}
	return 0;
}

顺序表实现

#include<stdio.h>
#define MAXNUM 100

typedef struct{
    int data[MAXNUM];
    int length;
}SqList;

int main(){
    SqList P;                    /*声明P的变量类型为SqList*/
    int i,j,k=1,id,m;            /*m为初始密码，id为人的编号*/
    printf("约瑟夫环问题的一种描述是：编号为1，2，...，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直到所有人全部出列为止。试设计一个程序求出出列顺序。 \n"); 
    printf("\n【顺序表实现】\n");
	printf("\n请输入总人数n和初始值m：\n");
    scanf("%d %d",&P.length,&m);
    for(i=0;i<P.length;i++) P.data[i]=i+1;
    int pwd[P.length];                          /*存储密码的数组*/
    printf("请输入每个人的密码：\n");
    for(i=0;i<P.length;i++) scanf("%d",&pwd[i]);    
    printf("出列顺序为：\n");
    while(P.length!=0){
        k--;
        i = (k+m-1)%(P.length);    /*计算出列的人的下标位置i*/
        id = P.data[i];             /*按下标查找出列的人的实际编号*/
        printf("%d ",id);
        m = pwd[i];                /*取出出列的人手中的密码作为新的密码m*/
        for(j=i;j<P.length-1;j++){     /*将出列的人后面的编号和密码依次往前移*/
           P.data[j]=P.data[j+1];
           pwd[j]=pwd[j+1];
        }
        P.length--;          /*线性表长度减1*/
        k=i+1;               /*接着从下一个开始数*/
    }
    printf("\n");
    return 0;
}

运行结果

约瑟夫问题经典版本（未持有密码）

源代码

typedef struct node {
    int number;
    struct node * next;
}person;
person * initLink(int n) {
    int i = 0;
    person * head = NULL, *cyclic = NULL;
    head = (person*)malloc(sizeof(person));
    head->number = 1;
    head->next = NULL;
    cyclic = head;
    for (i = 2; i <= n; i++) {
        person * body = (person*)malloc(sizeof(person));
        body->number = i;
        body->next = NULL;
        cyclic->next = body;
        cyclic = cyclic->next;
    }
    cyclic->next = head;//首尾相连
    return head;
}
void findAndKillK(person * head, int k, int m) {
    person * p = NULL;
    person * tail = head;
    //找到链表第一个结点的上一个结点，为删除操作做准备
    while (tail->next != head) {
        tail = tail->next;
    }
    p = head;
    //找到编号为k的人
    while (p->number != k) {
        tail = p;
        p = p->next;
    }
    //从编号为k的人开始，只有符合p->next==p时，说明链表中除了p结点，所有编号都出列了，
    while (p->next != p) {
        int i = 0;
        //找到从p报数1开始，报m的人，并且还要知道数m-1de人的位置tail，方便做删除操作。
        for (i = 1; i < m; i++) {
            tail = p;
            p = p->next;
        }
        tail->next = p->next;//从链表上将p结点摘下来
        printf("出列人的编号为:%d\n", p->number);
        free(p);
        p = tail->next;//继续使用p指针指向出列编号的下一个编号，游戏继续
    }
    printf("出列人的编号为:%d\n", p->number);
    free(p);
}

运行结果

可见，玩这个死亡游戏时，41个人围成一圈，从第一个人开始报数，每数到第三个人，那个人就suicide，那么理论上最后suicide的两个人是第16号和第31号，这样约瑟夫和他的朋友事先就判断这两个位序一定是最后出列的，他们就可以等其他39个人都suicide后，自己和朋友就可以逃过这场死亡游戏了。