使用循环链表的经典题目（约瑟夫、魔术师发牌、拉丁方阵）

一：约瑟夫问题

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

解决思路：
现在已知总人数N和报数数字n，要让Josephus和他的朋友活下来。我们先创建一个包含N个节点的循环链表，将每个人看作节点，data代表其位置，然后将报数者删除，最后剩下两个人时停止，这两个节点的data就是可存活位置。

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

typedef struct node
{
    int data;//data就是这个人所在位置
    struct node * next;
}N;
//下面创建链表（先创建好单链表然后将其最后一个节点指向开头）
N * create(int n)
{
    N * head=(N*)malloc(sizeof(N));
    N * fakehead=head;
    head->next=NULL;
    N * rear=(N*)malloc(sizeof(N));
    rear->next=NULL;
    N * p;
    for(int i=1;i<=n;i++)
    {
        p=(N*)malloc(sizeof(N));
        p->data=i;		//确定节点的位置，i特意从1开始
        p->next=NULL;
        fakehead->next=p;
        fakehead=p;
    }
    rear=p;
    rear->next=head->next;
    return rear;		//这里创建完的链表末尾用rear表示，rear->next即是首个节点
}
//下面模拟自杀流程
N * suicide(N * linktail,int count,int number)
{
    int k=1;
    N * nonius=linktail->next;	//nonius指向了首个位置的节点
    N * s;
    while(number!=2)//当总人数为2个时停止循环
    {
        while(k!=count-1)//当报数为n-1时停止循环，且循环停止后，nonius的位置仔报数者的前一个
        {
            nonius=nonius->next;
            k++;
        }
        s=nonius->next;	//用s确定死亡者位置
        nonius->next=s->next; //删除死亡者
        free(s);
        nonius=nonius->next;
        number--; //死亡一人，总人数-1
        k=1; //循环结束一次，k值归1
    }
    return nonius;
}
//下面输出位置
void site(N * nonius)
{
    printf("可存活位置是：");
    for(int i=0;i<2;i++)
    {
        printf("第%d个  ",nonius->data);
        nonius=nonius->next;
    }
}
//下面为主函数
int main()
{
    int number;
    int count;
    printf("请输入总人数：");
    scanf("%d",&number);
    printf("报数值是：");
    scanf("%d",&count);
    N * linktail=create(number);
    N * nonius=suicide(linktail,count,number);
    site(nonius);
    return 0;
}

输出结果：

二：魔术师发牌问题

问题描述：
魔术师发牌问题的简介：一位魔术师掏出一叠扑克牌，魔术师取出其中13张黑桃，洗好后，把牌面朝下。说：“我不看牌，只数一数就能知道每张牌是什么？”魔术师口中念一，将第一张牌翻过来看正好是A；魔术师将黑桃A放到桌上，继续数手里的余牌，第二次数1，2，将第一张牌放到这叠牌的下面，将第二张牌翻开，正好是黑桃2，也把它放在桌子上。第三次数1，2，3，前面二张牌放到这叠牌的下面，取出第三张牌，正好是黑桃3，这样依次将13张牌翻出，全部都准确无误。求解：魔术师手中牌的原始顺序是什么样子的？

解决思路：
题目中提到：
1，2，翻开2是黑桃2 。把1放到牌的末尾 ；
1，2，3，翻开是黑桃3。把1，2按顺序放到牌的末尾（先放1再放2）；
…
这里很明显的可以应用到循环链表。先生成一个含有13个节点的循环链表，每个节点包括：①这张牌的位置②这张牌的牌面③指向下一个节点的指针。然后开始循环模拟翻牌过程，翻牌是有规律的（1，1，2，1，2，3…），因此我们可以推理出翻开的牌的牌面，翻开的牌放到桌子上，在程序里将其表示为删除这个节点。为了保存翻开的牌的牌面，先定义一个数组来存放牌面值，对应的数组里的下标就是节点的位置。

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

typedef struct playingcard
{
	int data;	//牌面值
	int site;	//牌的位置
	struct playingcard * next;
}P;
//下面生成循环链表
P*create()
{
	P*head = (P*)malloc(sizeof(P));
	head->next = NULL;
	P*fakehead = head;
	P*rear = (P*)malloc(sizeof(P));
	rear->next = NULL;
	P*p;
	for (int i = 0; i < 13; i++)
	{
		p = (P*)malloc(sizeof(P));
		p->next = NULL;
		p->site = i + 1;	//给牌的位置赋值
		fakehead->next = p;
		fakehead = p;
	}
	rear = p;
	rear->next = head->next;	
	return rear;	//这里生成的链表用末尾元素表示，rear是尾元素，rear->next是第一个元素（为了方便寻找首元素和尾元素）
}
//下面模拟翻牌过程
void infer(P*rear)
{
	P*head = rear->next;
	P*pre = rear;
	int i = 0;
	int j = 0;
	int site = 0;
	int a[13];
	for (i = 0; i < 13; i++)	//翻牌13次，循环13次
	{
		for (j = 0; j < i; j++)	//循环模拟翻牌过程
		{
			head = head->next;
			pre = pre->next;	//为了方便删除节点，保留了要删除的节点的前一个节点
		}
		a[head->site-1] = i + 1;	//根据牌的位置将牌面赋值到数组
		pre->next = head->next;		//删除翻开的牌
		head = head->next;
	}
	for (int k = 0; k < 13; k++)	//输出结果
	{
		printf("黑桃%d\n", a[k]);
	}
}
//下面是主函数
int main()
{
	P*rear = create();
	infer(rear);
	getchar();
	return 0;
}

三、拉丁方阵

问题描述：拉丁方阵（英语：Latin square）是一种 n × n 的方阵，在这种 n × n 的方阵里，恰有 n 种不同的元素，每一种不同的元素在同一行或同一列里只出现一次。比如：

现在需要随机输入某个数字n，生成对应的n×n方阵。

解决思路：

在拉丁方阵里仔细观察是可以发现规律的，当第一行1 2 3确定后，第二行如何实现每一种不同的元素在同一行或同一列里只出现一次呢？很简单，我们移动1到末尾，2 3各向前提一位。第三行类似的，移动2到末尾，3 1 各向前提一位。其他规模的拉丁方阵的思路也是如此。很明显了，应用循环链表。

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

typedef struct node
{
	int data;
	struct node * next;
}N;

N * create_link(int n)
{
	printf("构建的拉丁方阵为：\n");
	N * head = (N*)malloc(sizeof(N));
	head->next = head;
	N * fakehead = head;
	N * p;
	for (int i = 0; i < n; i++)
	{
		p = (N*)malloc(sizeof(N));
		p->data = i + 1;
		fakehead->next = p;
		p->next = head->next;
		fakehead = p;
	}
	return head;
}

void latin(N * head , int n)
{
	int i = 0, j = 0;
	head = head->next;
	for ( i = 0; i < n; i++)
	{
		for ( j = 0; j < n; j++)
		{
			printf("%3d", head->data);
			head = head->next;
		}
		printf("\n");
		head = head->next;
	}
}

int main()
{
	int n;
	printf("请输入您要构建的拉丁方针的规模(比如3*3，输入3即可)：");
	scanf_s("%d",&n);
	N * head = create_link(n);
	latin(head, n);
	return 0;
}