数据结构作业--约瑟夫双向生死游戏

一、问题描述

本游戏的数学建模如下：假设n个旅客排成一个环形，依次顺序编号1，2，…，n。从某个指定的第1号开始，沿环计数，数到第m个人就让其出列，然后从第m+1个人反向计数到m-k+1个人，让其出列，然后从m-k个人开始重新正向沿环计数，再数m个人后让其出列，然后再反向数k 个人后让其出列。这个过程一直进行到剩下n/2个旅客为止。

采取的两种实现方式分别为链表和顺序表，所涉及的基本操作全部用函数实现

二、思路分析

1、链表实现

       1.1先定义出具有前驱和后继的结点

        1.2向前遍历和向后遍历以循环方式进行，找到目标后输出并进行删除

2、顺序表实现

      2.1先定义出数组存储乘客位置

      2.2采用标记位方式判断乘客有无出局

      2.3因为是循环队列，所以用取余方式判断

三、具体代码

1、链表部分

#include<stdio.h>
#include<stdlib.h>
typedef struct DuLNode
{
	int data;	   //数据域
	struct DuLNode* prior; //直接前驱
	struct DuLNode* next;  //直接后继
}DuLNode, * DuLinkList;

void begin() {
	printf("*************************************************\n");
	printf("*\t约瑟夫双向生死游戏开始\t*\n");
	printf("*\t请输入旅客的个数，正向离开旅客的间隔数和反向离开旅客的间隔数\t\t\t*\n");
}//菜单函数
DuLinkList createDulink(int n) {
	int i = 0;
	struct DuLNode* head = (struct DuLNode*)malloc(sizeof(struct DuLNode));
	head->data = 1;
	head->next = head;
	head->prior = head;
	struct DuLNode* p;
	struct DuLNode* tail = head;
	for (i = 0; i < n-1; i++) {
		p = (struct DuLNode*)malloc(sizeof(struct DuLNode));
		p->data = i + 2;
		while (tail->next != head) {
			tail = tail->next;
		}
		p->next = head;
		p->prior = tail;
		tail->next = p;
		head->prior = p;
		tail = p;
	}
	return head;
}//创造双循环链表函数
void printlist(DuLinkList d, int n,int m, int k) {
	struct DuLNode* p = d;
	int i = 1;
	printf("死者位置为：\n");
	while (i <=n/2 ) {
		struct DuLNode* q = p->next;
		for (int j = 1; j < m - 1; j++) { 
			p =p->next;
			q = p->next;
		}
		printf("%d ", q->data);
		p->next =q->next;
		q->next->prior = p;
		free(q);
		p = p->next;
		i++;
		if (i >n/2)break;
		struct DuLNode* l = p->prior;
		for (int j = 1; j < k - 1; j++) { 
			p = p->prior; 
			l = p->prior;
		}
		printf("%d ", l->data);
		p->prior = l->prior;
		l->prior->next = p;
		free(l);
		p = p->prior;
		i++;
		if (i > n/2)break;
	}
	printf("生者位置为：\n");
	for (int j = 0; j < n / 2; j++,p=p->next) {
		printf("%d ", p->prior->data);
	}
}//计算双向约瑟夫问题函数
int main() {
	begin();
	int n = 0, m = 0, k = 0;
	scanf("%d %d %d", &n, &m, &k);
	DuLinkList d= createDulink(n);
	printlist(d,n, m, k);
	
}

2、顺序表部分

#include<stdio.h>
#include<stdlib.h>
typedef struct {
	int* elem;  // 存储空间基址
	int length;// 当前长度，即现有元素个数
} queue;
void begin() {
	printf("*************************************************\n");
	printf("*\t约瑟夫双向生死游戏开始\t*\n");
	printf("*\t请输入旅客的个数，正向离开旅客的间隔数和反向离开旅客的间隔数\t\t\t*\n");
}
void ysf(int an,int am,int ak) {
	int n = an, m = am, k = ak, flag = 0;
	queue q;
	flag = m - 1;
	q.elem = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)q.elem[i] = i + 1;
	q.length = n;
	printf("*\t死者位置为：\t*\n");
	while (q.length > n / 2) {
		int i = 1;
		printf("%d  ", q.elem[flag]);
		q.elem[flag] = 0;
		q.length--; if (q.length <= n / 2)break;
		flag++;
		flag = (flag + n) % n;
		while (i < k) {
			flag--;
			flag = (flag + n) % n;
			if (q.elem[flag] != 0) { i++; }
		}
		i = 1;
		printf("%d  ", q.elem[flag]);
		q.elem[flag] = 0;
		q.length--; if (q.length <= n / 2)break;
		flag--;
		flag = (flag + n) % n;
		while (i < m) {
			flag++;
			flag = (flag + n) % n;
			if (q.elem[flag] != 0) { i++; }
			flag = (flag + n) % n;
		}
	}
	printf("\n");
	printf("*\t生者位置为：\t*\n");
	for (int i = 0; i < n; i++) {
		if (q.elem[i] != 0)
			printf("%d  ", q.elem[i]);

	}
	printf("\n");
	printf("*************************************************\n");
}
int main() {
	begin();
	int n = 0, m = 0, k = 0;
	scanf("%d %d %d", &n, &m, &k);
	ysf(n,m,k);
} 

四、思考与总结

   

1时间复杂度分析： 

1. 由操作过程可知顺序表时间复杂度为O(n*(m+k)/2),原因在于每次循环淘汰一名旅客时还行向前或向后移动m或k次，由于顺序表删除节点需循环移动空间造成时间复杂度过大，所以采用标记的方式标记淘汰的旅客不用删除节点
2. 由操作过程得知链表时间复杂度为O(n*(m+k)/2),采用双向循环链表，利用链表在删除节点时比顺序表高效特点

   2 空间复杂度分析：

     两者空间复杂度都为O(n)

综上所述，两者时间空间复杂度差不多，但链表在操作上更加简单便捷也更符合题目思想。