猴子选王

一堆猴子都有编号，编号是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;
}