链表应用：Josephus问题

今天学习了链表，找了一道经典的Josephus问题练习一下。该问题在百度百科的描述如下：

据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被人抓到，于是决定了一个自杀方式：41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

可以用循环链表来模拟这个过程，简单起见，将人进行编号，自杀的过程看作是数字出列，定义如下结构体：

struct node{
	int num;
	struct node *next;
};

typedef struct node Node;

输入人数（也就是“问题规模”）n和所谓的“自杀数字”（姑且称它为“间隔”吧）m，按出列顺序输出各数字，直到最后留下的那个数字。

问题的规模n暂且定义在2到10000之间，间隔m定义在1到n之间。其实m大于n也可以，只不过相当于多绕了一圈而已，因此暂定m小于n。

之后就是循环链表的生成和节点的删除了，直到最后只剩1个节点。

在写代码的过程中，个人感觉需要注意以下2个地方：

（1）要检查输入是否合理，例如是否是整数，是否符合取值范围。

（2）由于链表操作过程中，既要用到当前节点，又要用到当前节点的前驱，因此生成链表的初始化函数返回的是尾节点。反正是循环链表，首尾相接。这样一开始的时候，前驱指针就能指向尾节点，当前指针就能指向当前节点。否则，如果生成链表的初始化函数直接返回头结点，那么想找到尾节点的话，还要再遍历一次链表，麻烦了。

整个代码如下：

#include <stdio.h>
#include <stdlib.h>

#define N_MAX 10000		//人数n的最大取值

struct node{
	int num;
	struct node *next;
};

typedef struct node Node;

void SolveJosephus(unsigned int, unsigned int);
Node * InitJosephus(unsigned int);

int main(void)
{
	unsigned int m, n;	//m是间隔，n是问题规模

	printf("****** Josephus问题 ******\n\n");

	printf("输入规模 n （1 < n < %d）：", N_MAX);
	while(scanf("%u", &n) != 1 || n < 2 || n >= N_MAX) //检查输入n
	{
		while(getchar() != '\n') //剔除非数值输入
			continue;
		printf("输入有误！请输入整数n，且 1 < n < %d。\n", N_MAX);
		printf("重新输入规模 n （1 < n < %d）：", N_MAX);
	}

	printf("输入间隔 m （0 < m < %u）：", n);
	while(scanf("%u", &m) != 1 || m < 1 || m >= n) //检查输入m
	{
		while(getchar() != '\n')
			continue;
		printf("输入有误！请输入整数m，且 0 < m < %u。\n", n);
		printf("重新输入间隔 m （0 < m < %u）：", n);
	}

	SolveJosephus(n, m);

	return 0;
}

//解决Josephus问题，打印结果
void SolveJosephus(unsigned int n, unsigned int m)
{
	Node *pCurrent;		//指向当前节点
	Node *pPrevious;	//指向当前节点的前驱节点
	unsigned int k;		//计数器

	//初始化
	k = 1;
	pPrevious = InitJosephus(n);
	pCurrent = pPrevious->next;

	//打印表头
	printf("\n****** Josephus问题已解决 ******\n");
	printf("\n出列顺序  出列数字\n");

	//只剩下1个节点才结束循环，此时前驱就是自己
	while(pCurrent != pPrevious)
	{
		if (k % m != 0) //不该出列，则顺延
		{
			pPrevious = pCurrent;
			pCurrent = pPrevious->next;
		} 
		else //该出列了
		{
			//打印出列次序和当前节点的数字
			printf("%-10d%-10d\n", k/m, pCurrent->num);

			//删除当前节点
			pPrevious->next = pCurrent->next;
			free(pCurrent);
			pCurrent = pPrevious->next;
		}
		k++;
	}
	printf("\n最后留下的幸运数字是%d\n", pCurrent->num);
}

//创建具有n个节点的单向循环链表，n>=2，返回尾指针
Node * InitJosephus(unsigned int n)
{
	unsigned int i;		//节点的数字
	Node *head;			//链表的头指针
	Node *pCurrent;		//指向新建的节点
	Node *pPrevious;	//指向新建节点的前驱

	head = (Node *)malloc(sizeof(Node));
	head->num = 1;
	pPrevious = head;
	i = 2;
	while(i <= n)
	{
		pCurrent = (Node *)malloc(sizeof(Node));
		pCurrent->num = i;
		pPrevious->next = pCurrent;
		pPrevious = pCurrent;
		i++;
	}
	pCurrent->next = head; //首尾相接

	return pCurrent;
}

按照故事描述，输入n=41，m=3，看看结果。

嗯，没错。看来Josephus果然聪明过人，能在生死关头做出如此精确计算，佩服！