约瑟夫问题
    据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。 然而Josephus和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。
    问题：用循环链表模拟约瑟夫问题，把41个人自杀
    的顺序编号输出。
    代码：Josephus.c
    提高挑战难度：编号为1～N的N个人按顺时针方向围坐一圈，每人持有一个密码（正整数，可以自由输入），开始人选一个正整数作为报数上限值M，从第一个人按顺时针方向自1开始顺序报数，报道M时停止报数。报M的人出列，将他的密码作为新的M值，从他顺时针方向上的下一个人开始从1报数，如此下去，直至所有人全部出列为止。

    1. //n个人围圈报数，报m出列，最后剩下的是几号？
    2. #include <stdio.h>
    3. #include <stdlib.h>
    5. typedef struct node
    6. {
    7.     int data;
    8.     struct node *next;
    9. }node;
    11. node *create(int n)
    12. {
    13.     node *p = NULL, *he ad;
    14.     head = (node*)malloc(sizeof (node ));
    15.     p = head;
    16.     node *s;
    17.     int i = 1;
    19.     if( 0 != n )
    20.     {
    21.         while( i <= n )
    22.         {
    23.             s = (node *)malloc(sizeof (node));
    24.             s->data = i++;    // 为循环链表初始化，第一个结点为1，第二个结点为2。
    25.             p->next = s;
    26.             p = s;
    27.         }
    28.         s->next = head->next;
    29.     }
    31.     free(head);
    33.     return s->next ;
    34. }
    36. int main()
    37. {
    38.     int n = 41;
    39.     int m = 3;
    40.     int i;
    41.     node *p = create(n);
    42.     node *temp;
    44.     m %= n;   // m在这里是等于2
    46.     while (p != p->next )
    47.     {
    48.         for (i = 1; i < m-1; i++)
    49.         {
    50.             p = p->next ;
    51.         }
    53.         printf("%d->", p->next->data );
    55.         temp = p->next ;                //删除第m个节点
    56.         p->next = temp->next ;
    57.         free(temp);
    59.         p = p->next ;
    60.     }
    62.     printf("%d\n", p->data );
    64.     return 0;
    65. }

    魔术师发牌问题
    问题描述：
    魔术师利用一副牌中的13张黑牌，预先将他们排好后叠放在一起，牌面朝下。对观众说：“我不看牌，只数数就可以猜到每张牌是什么，我大声数数，你们听，不信？现场演示。”魔术师将最上面的那张牌数为1，把他翻过来正好是黑桃A，将黑桃A放在桌子上，第二次数1,2，将第一张牌放在这些牌的下面，将第二张牌翻过来，正好是黑桃2，也将它放在桌子上这样依次进行将13张牌全部翻出，准确无误。
    问题：牌的开始顺序是如何安排的？

    1. #include <stdio.h>
    2. #include <stdlib.h>
    4. #define  CardNumber 13
    6. typedef struct node
    7. {
    8.     int data;
    9.     struct node *next;
    10. }sqlist, *linklist;
    12. linklist CreateLinkList()
    13. {
    14.     linklist head = NULL;
    15.     linklist s, r;
    16.     int i;
    18.     r = head;
    20.     for(i=1; i <= CardNumber; i++)
    21.     {
    22.         s = (linklist)malloc(sizeof(sqlist));
    23.         s->data = 0;
    25.         if(head == NULL)
    26.             head = s;
    27.         else
    28.             r->next = s;
    30.         r = s;
    31.     }
    33.     r->next = head;
    35.     return head;
    36. }
    38. // 发牌顺序计算
    39. void Magician(linklist head)
    40. {
    41.     linklist p;
    42.     int j;
    43.     int Countnumber = 2;
    45.     p = head;
    46.     p->data = 1;  //第一张牌放1
    48.     while(1)
    49.     {
    50.         for(j=0; j < Countnumber; j++)
    51.         {
    52.             p = p->next;
    53.             if(p->data != 0)  //该位置有牌的话,则下一个位置
    54.             {
    55.                 p->next;
    56.                 j--;
    57.             }
    58.         }
    60.         if(p->data == 0)
    61.         {
    62.             p->data = Countnumber;
    63.             Countnumber ++;
    65.             if(Countnumber == 14)
    66.                 break;
    67.         }
    68.     }
    69. }
    71. // 销毁工作
    72. void DestoryList(linklist* list)
    73. j
    74. }
    76. int main()
    77. {
    78.     linklist p;
    79.     int i;
    81.     p = CreateLinkList();
    82.     Magician(p);
    84.     printf("按如下顺序排列：\n");
    85.     for (i=0; i < CardNumber; i++)
    86.     {
    87.         printf("黑桃%d ", p->data);
    88.         p = p->next;
    89.     }
    91.     DestoryList(&p);
    93.     return 0;
    94. }

    拉丁方阵问题
    拉丁方阵是一种n×n的方阵，方阵中恰有n种不同的元素，每种元素恰有n个，并且每种元素在一行和一列中 恰好出现一次。著名数学家和物理学家欧拉使用拉丁字母来作为拉丁方阵里元素的符号，拉丁方阵因此而得名。

    例如3下图是一个3×3的拉丁方阵：
    eg3：约瑟夫问题 - 图1