5.单向链表的经典问题（约瑟夫环，拉丁方阵，魔术师发牌问题，判断链表是否有环）

目录

1.约瑟夫问题

      1.1经典的约瑟夫问题

      1.2更加复杂的约瑟夫问题

2.拉丁方阵问题

3.判断单链表是否含有环

       3.1  比较步数法

       3.2  快慢指针法

4. 魔术师发牌问题

5.几个经典问题的编程实现

       5.1 C语言实现循环链表

       5.2 测试结果

6. 参考资料

---

1.约瑟夫问题

约瑟夫问题跟当下流行的吃鸡游戏非常类似，本身就是一个生存游戏，与吃鸡游戏不同的是，这个游戏靠的不是钢枪或者当伏地魔，而是用数学规则来决定生死！

      1.1经典的约瑟夫问题

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

问题：用循环链表模拟约瑟夫问题，把41个人自杀的顺序编号输出。

解决方法：下图是核心程序，完整程序可以参考第4部分，有比较详细的注解。

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *Next;
}Node;

typedef Node* linklist;//给节点指针取别名
typedef enum Bool
{
    FALSE,TRUE//枚举默认值从0开始，依次加1
}Bool;
void CreateListEnd(linklist* L,int n);//尾插法创建链表
void Josephus(linklist* L);//经典的约瑟夫问题

void CreateListEnd(linklist* L,int n)//新建循环链表
{
    linklist p,rear;
    int i;

    (*L)=(linklist)malloc(sizeof(Node));
    if((*L)==NULL)
    {
        printf("结点申请失败，初始化未完成！\n");
        exit(0);
    }
    (*L)->data=1;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklist)malloc(sizeof(Node));
        p->data=i+1;//rand()%100+1;
        p->Next=*L;//新节点是新的尾节点，它指向头结点
        rear->Next=p;
        rear=rear->Next;
    }
}

void Josephus(linklist* L)//约瑟夫环
{
    linklist p;//指向待删结点的前面
    linklist q;
    int i=0;
    for(p=(*L)->Next;p->Next!=p;p=p->Next->Next)
        /*假设每次报数m个死一个人，则
 * 1.起始p从头向后移动m-2次；
 * 2.后续循环中，p每次向后移动m-1次。
* */
    {
        q=p->Next;
        p->Next=q->Next;
        printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++i);
        free(q);
    }
    printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);
    free(p);
}

      1.2更加复杂的约瑟夫问题

编号为1～N的N个人按顺时针方向围坐一圈，每人持有一个密码（正整数，可以自由输入），开始人选一个正整数作为报数上限值M，从第一个人按顺时针方向自1开始顺序报数，报道M时停止报数。报M的人出列，将他的密码作为新的M值，从他顺时针方向上的下一个人开始从1报数，如此下去，直至所有人全部出列为止。

问题：模拟这个问题的自杀编号。

基本思路：用含有两个数据域的循环链表来实现，第一个数据域data存放游戏者的编号，第二个数据域code存放此人的密码，程序设计与经典的约瑟夫问题基本相同。基本数据结构为：

typedef struct NodeCode
{
    int data;//玩家编号
    int code;//密码
    struct Node *Next;
}NodeCode;   //带密码的约瑟夫环的结点
typedef NodeCode* linklistcode;//给节点指针取别名

核心程序为：  

void CreateListEndCode(linklistcode* L,int n);//尾插法创建带密码的约瑟夫环
void printListCode(linklistcode L);//遍历约瑟夫环
void JosephusCode(linklistcode* L,int M);//更加复杂的约瑟夫问题

void CreateListEndCode(linklistcode* L,int n)//尾插法创建带密码的约瑟夫环
{
    linklistcode p,rear;
    int i;

    (*L)=(linklistcode)malloc(sizeof(NodeCode));
    if((*L)==NULL)
    {
        printf("结点申请失败，初始化未完成！\n");
        exit(0);
    }
    (*L)->data=1;//
    (*L)->code=rand()%100+1;//3;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklistcode)malloc(sizeof(NodeCode));
        p->data=i+1;//
        p->code=rand()%100+1;//3;//
        p->Next=*L;//新节点是新的尾节点，它指向头结点
        rear->Next=p;
        rear=rear->Next;
        //
    }
}

void printListCode(linklistcode L)
{
    linklistcode p=L;
    if(L==NULL)
    {
        printf("当前循环链表是空链表  \n\n\n");
        return;
    }

    printf("\n玩家编号%3d",p->data);//第一个结点的元素值
    for(p=p->Next;p!=L;p=p->Next)
        printf("%4d",p->data);

    printf("\n玩家密码%3d",L->code);//第一个结点的元素值
    for(p=L->Next;p!=L;p=p->Next)
        printf("%4d",p->code);
    printf("\n\n");
}

void JosephusCode(linklistcode* L,int M)
{
    /*假设每次报数m个死一个人，则
* 1.起始p从头向后移动m-2次；
* 2.后续循环中，p每次向后移动m-1次。
*/
    linklistcode p=*L,q;//指向待删结点的前面
    int i,num;

    for(i=0;i<M-2;i++)
        p=p->Next;

    num=0;
    while(p->Next!=p)
    {
        q=p->Next;
        p->Next=q->Next;
        printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++num);
        M=q->code;
        free(q);
        for(i=0;i<M-1;i++)
            p=p->Next;
    }
    printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);
    free(p);
}

2.拉丁方阵问题

拉丁方阵是大家熟知的数独的起源，规则比数独稍微简单一些。

问题描述：

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

当一个拉丁方阵的第一行与第一列的元素按顺序排列时，此为这个拉丁方阵的标准型，英语称为"reduced Latin square, normalized Latin square, 或Latin square in standard form"。因为标准型拉丁方阵非常简单，所以下面就实现标准型。

思路分析：

标准型拉丁方阵的基本特点是，第一行按1,2,3...n的顺序排列；第二行就是将第一行循环右移一位，即2,3,4，.....,n,1；以此类推，后续每一行的数据都是他的前一行数据循环右移一位形成的。标准型拉丁方阵的这种特点很适合用循环链表来实现：

void Latin(int n);
void Latin(int n)
{
    linklist list,head,p;//head每次后移一位，表示拉丁方阵每一行的新起点位置
    int i;
    CreateListEnd(&list,n);//创建单链表
    head=list;
    for(i=0;i<n;i++)
    {
        p=head;
        printf("\n%d  ",p->data);//第一个结点的元素值
        for(p=p->Next;p!=head;p=p->Next)
            printf("%d  ",p->data);
        head=head->Next;
    }
    printf("\n\n");
}

3.判断单链表是否含有环

单链表中含有环的定义是，链表的尾节点指向了链表的某个结点，而不是指向空。例如下面的单链表就含有环： 

解决这个问题主要有两种方法：比较步数法，和快慢指针法。

       3.1  比较步数法

开始的时候有两个指针p和q，他们都指向链表第一个结点，p每次往后遍历一个结点，而q每次都从链表的第一个结点开始，p每往后遍历一次就比较二者相遇（二者指向同一个结点）各时自遍历的步数，当步数不同的时候，说明有环。核心程序如下：

Bool haveCirc1(linklist L)
{
    linklist p,q;
    int p_step,q_step,i=0;

    for(p=L,p_step=1;p!=NULL;p=p->Next,p_step++)
    {
        for(q=L,q_step=1;q!=NULL;q=q->Next,q_step++)
        {
            i++;
            if(p==q)
            {
                if(q_step!=p_step)
                {
                    printf("该链表含有环，循环结点位置为：%d    循环语句执行%d次\n",q_step,i);
                    return TRUE;
                }
                else
                    break;
            }
        }

    }
    printf("当前链表无环， 循环语句共执行了%d次\n",i);
    return FALSE;
}

       3.2  快慢指针法

刚开始的时候快慢指针都指向链表第一个结点，每次快指针向前走两步，而慢指针每次只往前走一步，当二者在运动的过程中发生相遇时，说明存在环。

Bool haveCirc2(linklist L)
{
    linklist fast,slow;
    int i;
    slow=fast=L;

    for(i=1;(fast->Next!=NULL)&&(fast->Next->Next!=NULL);)
    {
        fast=fast->Next->Next;//fast的结点数依次为：3/5/7/9...
        if(fast==slow||fast->Next==slow)
            //fast的结点数依次为：3/5/7/9...，而slow为1/2/3/4...，无环时二者不可能相遇，fast更不可能出现在slow后面
        {
            printf("该链表含有环，循环语句执行%d次\n\n",i);
            return TRUE;
        }
        slow=slow->Next;//分别为1/2/3...
        i++;
    }
    printf("当前链表无环， 循环语句共执行了%d次\n\n",i-1);
    return FALSE;
}

4. 魔术师发牌问题

问题描述

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

求解：魔术师手中牌的原始顺序是什么样子的？

基本思路

假设手中有13张牌，当牌没有翻开的时候可以给他标记为0，当牌翻开后标记为实际的数字。这样一来问题就变得简单了，可以使用循环链表来实现：首先创建一个长度为13的循环链表，链表中所有元素都是0，表示13张牌都是未知状态，然后给第一个元素标记上实际数字1，这时候第一张牌非0，只要是非0就表示这个位置的牌放在了桌子上，要从剩下的元素为0的12个结点中再数2个，给第2个标记上数字2；依次类推。。。

程序中需要注意的是，每次计数的时候只计数不在桌子上的牌，即链表中元素为0的结点。

核心程序如下：

void InitCards(linklist* L,int n);//尾插法创建全0链表
void MagicianDealingCards(linklist* L,int n);//确定每张牌的位置
void displayCards(linklist L);//将所有牌按顺序显示
void InitCards(linklist* L,int n)
{
    linklist p,rear;
    int i;

    (*L)=(linklist)malloc(sizeof(Node));
    (*L)->data=0;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklist)malloc(sizeof(Node));
        p->data=0;//rand()%100+1;
        p->Next=*L;//新节点是新的尾节点，它指向头结点
        rear->Next=p;
        rear=rear->Next;
    }
}

void MagicianDealingCards(linklist* L,int n)
{
    linklist p=*L;
    int num,i;//每次发牌前计数的个数为num个
    p->data=1;
    for(num=2;num<=n;num++)
    {
        for(i=0;i<num;)
        {
            p=p->Next;
            if(p->data==0)//这个位置的牌已经放在桌子上了
                i++;
        }
        p->data=num;
    }
}

void displayCards(linklist L)
{
    linklist p=L;
    char card[13]={'A','2','3','4','5','6','7','8','9','10','J','Q','K'};
    printf("黑桃%c  ",card[L->data-1]);//第一张肯定是A
    for(p=p->Next;p!=L;p=p->Next)
        printf("黑桃%c  ",card[p->data-1]);

    printf("\n\n");
}

5.几个经典问题的编程实现

       5.1 C语言实现循环链表

（1）循环链表的声明 cirlinklist.h

#ifndef CIRLINKLIST_H
#define CIRLINKLIST_H

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *Next;
}Node;

typedef Node* linklist;//给节点指针取别名
typedef enum Bool
{
    FALSE,TRUE//枚举默认值从0开始，依次加1
}Bool;

typedef struct NodeCode
{
    int data;//玩家编号
    int code;//密码
    struct Node *Next;
}NodeCode;   //带密码的约瑟夫环的结点
typedef NodeCode* linklistcode;//给约瑟夫环的指针取别名


void CreateListEnd(linklist* L,int n);//尾插法创建链表
void traverseList(linklist L);//遍历链表

//1.约瑟夫环
void Josephus(linklist* L);//经典的约瑟夫问题
void CreateListEndCode(linklistcode* L,int n);//尾插法创建带密码的约瑟夫环
void printListCode(linklistcode L);//遍历约瑟夫环
void JosephusCode(linklistcode* L,int M);//更加复杂的约瑟夫问题

//2.拉丁方阵
void Latin(int n);

//3.判断链表是否有环
#if 0
判断是否有环的2种方法:
1.两个指针，p每次继续往后遍历一个结点，而q每次从头开始，记录二者相遇时（同一个结点，即结点的地址相同）各自遍历的步数，当步数不同的时候，说明有环；
2.用快慢指针的方法：快慢指针相遇的时候说明有环
#endif
void CreateSingleListEnd(linklist* L,int n);//尾插法创建单链表
void displaySingleList(linklist L);//显示单链表
void CreateCirListEnd(linklist* L,int n);//尾插法创建带环链表
void displayCirList(linklist L,int n);//显示循环链表，只循环显示n个元素即可
Bool haveCirc1(linklist L);//方法一：比较步数法
Bool haveCirc2(linklist L);//方法二：快慢指针法

//4.魔术师发牌问题
/*0表示这张牌还没有翻开*/
void InitCards(linklist* L,int n);//尾插法创建全0链表
void MagicianDealingCards(linklist* L,int n);//确定每张牌的位置
void displayCards(linklist L);//将所有牌按顺序显示
#endif // CIRLINKLIST_H

（2） 循环链表的实现 cirlinklist.c

#include "cirlinklist.h"
#include <stdio.h>

void traverseList(linklist L)
{
    linklist p=L;
    if(L==NULL)
    {
        printf("当前循环链表是空链表  \n\n\n");
        return;
    }
    else
        printf("%d  ",p->data);//第一个结点的元素值

    for(p=p->Next;p!=L;p=p->Next)
    {
        printf("%d  ",p->data);
        //        p=p->Next;
    }
    printf("\n\n");
}

void CreateListEnd(linklist* L,int n)
{
    linklist p,rear;
    int i;

    (*L)=(linklist)malloc(sizeof(Node));
    if((*L)==NULL)
    {
        printf("结点申请失败，初始化未完成！\n");
        exit(0);
    }
    (*L)->data=1;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklist)malloc(sizeof(Node));
        p->data=i+1;//rand()%100+1;
        p->Next=*L;//新节点是新的尾节点，它指向头结点
        rear->Next=p;
        rear=rear->Next;
    }
}



void Josephus(linklist* L)
{
    linklist p;//指向待删结点的前面
    linklist q;
    int i=0;
    for(p=(*L)->Next;p->Next!=p;p=p->Next->Next)
        /*假设每次报数m个死一个人，则
 * 1.起始p从头向后移动m-2次；
 * 2.后续循环中，p每次向后移动m-1次。
* */
    {
        q=p->Next;
        p->Next=q->Next;
        printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++i);
        free(q);
    }
    printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);
    free(p);
}

void CreateListEndCode(linklistcode* L,int n)//尾插法创建带密码的约瑟夫环
{
    linklistcode p,rear;
    int i;

    (*L)=(linklistcode)malloc(sizeof(NodeCode));
    if((*L)==NULL)
    {
        printf("结点申请失败，初始化未完成！\n");
        exit(0);
    }
    (*L)->data=1;//
    (*L)->code=rand()%100+1;//3;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklistcode)malloc(sizeof(NodeCode));
        p->data=i+1;//
        p->code=rand()%100+1;//3;//
        p->Next=*L;//新节点是新的尾节点，它指向头结点
        rear->Next=p;
        rear=rear->Next;
        //
    }
}

void printListCode(linklistcode L)
{
    linklistcode p=L;
    if(L==NULL)
    {
        printf("当前循环链表是空链表  \n\n\n");
        return;
    }

    printf("\n玩家编号%3d",p->data);//第一个结点的元素值
    for(p=p->Next;p!=L;p=p->Next)
        printf("%4d",p->data);

    printf("\n玩家密码%3d",L->code);//第一个结点的元素值
    for(p=L->Next;p!=L;p=p->Next)
        printf("%4d",p->code);
    printf("\n\n");
}

void JosephusCode(linklistcode* L,int M)
{
    /*假设每次报数m个死一个人，则
* 1.起始p从头向后移动m-2次；
* 2.后续循环中，p每次向后移动m-1次。
*/
    linklistcode p=*L,q;//指向待删结点的前面
    int i,num;

    for(i=0;i<M-2;i++)
        p=p->Next;

    num=0;
    while(p->Next!=p)
    {
        q=p->Next;
        p->Next=q->Next;
        printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++num);
        M=q->code;
        free(q);
        for(i=0;i<M-1;i++)
            p=p->Next;
    }
    printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);
    free(p);
}


void Latin(int n)
{
    linklist list,head,p;//head每次后移一位，表示拉丁方阵每一行的新起点位置
    int i;
    CreateListEnd(&list,n);//创建单链表
    head=list;
    for(i=0;i<n;i++)
    {
        p=head;
        printf("\n%d  ",p->data);//第一个结点的元素值
        for(p=p->Next;p!=head;p=p->Next)
            printf("%d  ",p->data);
        head=head->Next;
    }
    printf("\n\n");
}

void CreateSingleListEnd(linklist* L,int n)
{
    linklist p,end;
    int i;

    *L=(linklist)malloc(sizeof(Node));
    (*L)->data=1;
    end=*L;

    for(i=1;i<n;i++)
    {
        p=(linklist)malloc(sizeof(Node));
        p->data=i+1;//rand()%100+1;
        p->Next=NULL;
        end->Next=p;
        end=p;
    }
}

void displaySingleList(linklist L)
{
    linklist p=L;

    while(p)
    {
        printf("%d  ",p->data);
        p=p->Next;
    }
    printf("\n");
}

void CreateCirListEnd(linklist* L,int n)
{
    linklist p,rear;
    int i;

    (*L)=(linklist)malloc(sizeof(Node));
    (*L)->data=1;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklist)malloc(sizeof(Node));
        p->data=i+1;//rand()%100+1;

        rear->Next=p;
        rear=rear->Next;
        //
    }
    rear->Next=(*L)->Next->Next->Next;//循环到第4个结点
}

void displayCirList(linklist L,int n)
{
    linklist p=L;
    int i;
    if(L==NULL)
    {
        printf("当前循环链表是空链表  \n\n\n");
        return;
    }
    printf("%d  ",p->data);//第一个结点的元素值

    for(i=1;i<n;i++)
    {
        p=p->Next;
        printf("%d  ",p->data);
    }
    printf("\n");
}

Bool haveCirc1(linklist L)
{
    linklist p,q;
    int p_step,q_step,i=0;

    for(p=L,p_step=1;p!=NULL;p=p->Next,p_step++)
    {
        for(q=L,q_step=1;q!=NULL;q=q->Next,q_step++)
        {
            i++;
            if(p==q)
            {
                if(q_step!=p_step)
                {
                    printf("该链表含有环，循环结点位置为：%d    循环语句执行%d次\n",q_step,i);
                    return TRUE;
                }
                else
                    break;
            }
        }

    }
    printf("当前链表无环， 循环语句共执行了%d次\n",i);
    return FALSE;
}

Bool haveCirc2(linklist L)
{
    linklist fast,slow;
    int i;
    slow=fast=L;

    for(i=1;(fast->Next!=NULL)&&(fast->Next->Next!=NULL);)
    {
        fast=fast->Next->Next;//fast的结点数依次为：3/5/7/9...
        if(fast==slow||fast->Next==slow)
            //fast的结点数依次为：3/5/7/9...，而slow为1/2/3/4...，无环时二者不可能相遇，fast更不可能出现在slow后面
        {
            printf("该链表含有环，循环语句执行%d次\n\n",i);
            return TRUE;
        }
        slow=slow->Next;//分别为1/2/3...
        i++;
    }
    printf("当前链表无环， 循环语句共执行了%d次\n\n",i-1);
    return FALSE;
}

void InitCards(linklist* L,int n)
{
    linklist p,rear;
    int i;

    (*L)=(linklist)malloc(sizeof(Node));
    (*L)->data=0;//
    (*L)->Next=*L;//第一个结点
    rear=*L;

    for(i=1;i<n;i++)
    {
        p=(linklist)malloc(sizeof(Node));
        p->data=0;//rand()%100+1;
        p->Next=*L;//新节点是新的尾节点，它指向头结点
        rear->Next=p;
        rear=rear->Next;
    }
}

void MagicianDealingCards(linklist* L,int n)
{
    linklist p=*L;
    int num,i;//每次发牌前计数的个数为num个
    p->data=1;
    for(num=2;num<=n;num++)
    {
        for(i=0;i<num;)
        {
            p=p->Next;
            if(p->data==0)//这个位置的牌已经放在桌子上了
                i++;
        }
        p->data=num;
    }
}

void displayCards(linklist L)
{
    linklist p=L;
    char card[13]={'A','2','3','4','5','6','7','8','9','10','J','Q','K'};
    printf("黑桃%c  ",card[L->data-1]);//第一张肯定是A
    for(p=p->Next;p!=L;p=p->Next)
        printf("黑桃%c  ",card[p->data-1]);

    printf("\n\n");
}

（3）测试程序 main.c

#include <stdio.h>
#include "cirlinklist.h"

int main()
{

    linklist list;
    int num;
    linklistcode listcode;

    printf("\n\n             11.约瑟夫环\n");
    CreateListEnd(&list,41);
    printf("原链表\n");
    traverseList(list);
    Josephus(&list);

    printf("\n\n             12.带密码的约瑟夫环\n");
    CreateListEndCode(&listcode,50);
    printf("原链表\n");
    printListCode(listcode);
    JosephusCode(&listcode,3);

    printf("\n\n             13.拉丁方阵\n");
    printf("请输入拉丁方阵的阶数：");
    scanf("%d",&num);
    Latin(num);

    printf("\n\n             14.判断链表是否含有环\n");
    linklist singlist,circlist;
    printf("\n测试单链表");
    CreateSingleListEnd(&singlist,10);
    displaySingleList(singlist);
    printf("方法一：逐个遍历法\n");
    haveCirc1(singlist);
    printf("\n方法二：快慢指针法\n");
    haveCirc2(singlist);

    printf("\n测试带环的链表");
    CreateCirListEnd(&circlist,10);
    displayCirList(circlist,10+2);//多显示两个，可以看到循环点的位置
    printf("方法一：逐个遍历法\n");
    haveCirc1(circlist);
    printf("\n方法二：快慢指针法\n");
    haveCirc2(circlist);

    printf("\n\n             15.魔术师发牌问题\n");
    linklist cards;
    InitCards(&cards,13);
    MagicianDealingCards(&cards,13);
    displayCards(cards);
    return 0;
}

       5.2 测试结果

（1）经典的约瑟夫环

（2）更加复杂的约瑟夫环

(3）拉丁方阵

(4) 判断单链表是否有环

(5)魔术师发牌问题

6. 参考资料

[1]小甲鱼的教学视频：https://www.bilibili.com/video/av2975983/?p=18

[2]百度百科，拉丁方阵：https://baike.baidu.com/item/%E6%8B%89%E4%B8%81%E6%96%B9%E9%98%B5/4413910

[3]百度经验，魔术师发牌问题：https://jingyan.baidu.com/article/0aa223755363c688cc0d6485.html

[4]单链表是否有环的基本思路：https://www.bilibili.com/video/av2975983/?p=19