猴子选王

一堆猴子都有编号，编号是1，2，3 ...m，这群猴子（m个）按照1-m的顺序围坐一圈，从第1开始数，每数到第n个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王。
要求：m及n要求从键盘输入，存储方式采用向量及链表两种方式实现该问题求解。 

（1）采用数组方法来实现，主要思路是，先采用动态分配内存来得到一个一维的长度为m的整型数组，并且赋值为相对应猴子的编号，用一个计数器来数数，得到要出列的猴子的编号，然后这个猴子的编号为0，表示出列。循环查找要出列猴子的编号，直到只剩下一个猴子。在查找猴子出列的过程中，当遇到数组的下标到达尾部时，使下标重新到数组的头部，即使数组的下标为0。代码如下：
#include <stdio.h>

#include <stdlib.h>

int getcount(int *p,int m,int n);

int main()

{

    int *p;

    int m,n,i,j,flag,temp;

    while(1){

    scanf("%d%d",&m,&n);

    p=(int *)malloc(sizeof(int)*m);

    for(i=0;i<m;i++)

        p[i]=i+1;

    printf("猴王的编号%d\n",getcount(p,m,n));

    }

    free(p);

    return 0;

}

int getcount(int *p,int m,int n)

{

    int i,temp,flag,count;

    temp=0;

    count=m;

     while(count!=1)

    {

        flag=1;             //计数器

        while(flag<n)   //查找要删除的猴子的编号

        {

            if(temp>=m)

                temp=0;

            if(p[temp]!=0)

            {

                flag++;

            }

            temp++;

        }

        if(temp>=m)

            temp=0;

        while(temp<m&&p[temp]==0)

            {

                   temp++;

                   if(temp>=m)

                       temp=0;

            }      //跳过已删除猴子的标号

        p[temp]=0;

        count-=1;    //剩下猴子的个数-1

    }

    for(i=0;i<m;i++)

    {

        if(p[i]!=0)

        {

            return p[i];

        }

    }

}

（2）链表方式：
一种是采用循环链表的方式，另一种是采用单链表的方式，二者主要的区别是循环链表不需要考虑到达尾部的情况，而单链表需要考虑到链表的尾部的情况，单链表到链表尾部时要重新是指针指向头部。思路是，用一个计数器来计数，然后来查找出列的猴子编号，循环链表需要一个指针来指向当前指针的位置，及当前指针的前驱，而单链表需要一个头指针。循环查找直到剩下一个猴子时退出。代码如下：
#include <stdio.h>

#include <stdlib.h>

struct num

{

    int number;

    struct num *next;

};

int getnumber(int m,int n);

int getnumber1(int m,int n);

int main()

{

    int m,n;

    scanf("%d%d",&m,&n);

    printf("循环链表：猴王编号为:%d\n\n\n",getnumber(m,n));

    printf("单向链表：猴王编号为:%d\n",getnumber1(m,n));

    return 0;

}

int getnumber(int m,int n)

{

    struct num *p,*p1,*head,*temp;

    int i=0,flag;

    p=(struct num*)malloc(sizeof(struct num));

    head=p;

    while(i<m)

    {

        p1=p;

        p->number=i+1;

        p=(struct num*)malloc(sizeof(struct num));

        p1->next=p;

        i++;

    }

    p1->next=head;     //形成环状列表

    free(p);

    temp=p1; //temp当前指针的前驱

    i=1;

    while(i<m)

    {

        flag=1;     //计数器

        //查找要删除的编号的指针

        while(flag<n)

        {

            temp=head;

            head=head->next;

            flag++;

        }

        temp->next=head->next;

        printf("删除猴子的编号:%d\n",head->number);

        free(head);

        head=temp->next;

        i++;

    }

    return head->number;

}

int getnumber1(int m,int n)

{

    struct num *p,*p1,*head,*temp;

    int i=0,flag;

    p=(struct num*)malloc(sizeof(struct num));

    head=p;

    if(n==1)

        return m;

    while(i<m)

    {

        p1=p;

        p->number=i+1;

        p=(struct num*)malloc(sizeof(struct num));

        p1->next=p;

        i++;

    }

    p1->next=NULL;   //形成单向链表

    p=head;

    i=0;

    flag=0;

    while(i!=m-1)

    {

        if(flag==n-1)

        {

            printf("删除猴子的编号:%d\n",p->number);

            if(p==head)   //当删除的节点位于节点头时

            {

                head=head->next;

                p=head;

            }

            else if(p->next==NULL) //当初节点位于节点尾时

            {

                temp->next=NULL;

                p=head;

            }

            else                   //位于中间

            {

                temp->next=p->next;

                p=p->next;

            }

            i++;

            flag=0;

        }
      //当指针到达链表尾部是，使其指向头指针。
        if(p->next==NULL)

        {

            p=head;

        }

        else

        {

            temp=p;

            p=p->next;

        }

        flag++;

    }

    return head->number;

}