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

typedef struct node
{
    int number;
    int password;
    struct node *next;
}person;
typedef person *personlist;
/* 得到一个头指针 */

void initlist(person *l)
{
    person *head,*rear;
    head=(person*)malloc(sizeof(person));    /* 得到一个头结点 */
    rear=head;                                /* 让该链表为一条循环单链表 */
}
/* 初始化链表 */

void Dellist(personlist l,int e)
{
    person *r,*p;
    p=l->next;                /* 让指针p指向头结点，从链表开始从头查找*/
    while(p->next!=l->next)    /* 当头结点指向自己的时候，表示删除完毕*/
    {
        p=p->next;            /* 指针在链表上移动*/
        if((p->number)==e)
            {
                r=p->next;
                p->next=r->next;
                free(r);
            }            /* 当指针指向的当前该结点的值时，删除该结点，并且释放结点空间*/
    }
}
/* 删除链表中与e相等的值 */

int createlist(personlist l)
{
    person *rear,*s;
    int x,y;            /* 让x和y分别赋值给结点上的号码与密码 */
    int n;
    n=0;                /* n为输入的人数 */
    int flag=1;
    rear=l->next;
    while(flag)
    {
        if(x!=(-1))        /*当输入的号码为-1时，结束输出 */
        {
            s=(personlist)malloc(sizeof(person));
            scanf("%d,%d",&x,&y);
            s->number=x;
            s->password=y;
            rear->next=s;
            rear=s;
            n++;
        }
        else
        {
            flag=0;
            rear->next=l->next;    /* 让末尾结点指针指向头结点 */
        }
    }
return n;
}
/* 成功建立了一个链表 */

int showlist(personlist l,int k)
{
    person *p;
    int n;
    int flag;
    p=l->next->next;
    n=1;
    flag=1;
    while(flag)
    {
        if(n<=k)
        {
            printf("%d",*p);
            p=p->next;
            n++;
        }        
        else
            flag=0;
    }
return n;
}
/* 为了检验，输出所有人的密码 */

void yuesefu(person *l,int m)
{
    person *p;
    p=l->next;
    while(p->next!=l->next)
    {
        p=p->next;
        if((p->number)==m)
        {
            printf("%d,%d",p->number,p->password);
            m=(p->password);
        }
        Dellist(l,m);
    }
}
/* 让指针在链表上移动并查找与m相匹配密码的人，输出，且将其删除 */

int main()
{
    person *l;
    initlist(l);

    int y;
    y=createlist(l);

    showlist(l,y);

    int x;
    x=20;
    yuesefu(l,x);

    return 0;
}
/* 编写主函数 */

/*看了下，编程习惯不错，这种写法真的让我大开眼界。但是你的建立循环链表就开始错了，其他的也就不说了。还有后面那个m是序号还是密码没明白，给你个例子你看下循环链表实现的约瑟夫环，c++写的，写的简单，参考下。你写写你的思路，我看下是个什么样的约瑟夫环，我帮忙改下，也学习下。*/#include <iostream>
using namespace std;
typedef struct Node
{    int data;
    struct Node *next;
}ListNode;
void Create(ListNode *head)
{    ListNode *p,*q;
    p=head;
    int n;
    cout<<"猴子的总数n:"<<endl;
    cin>>n;
    for(int i=0;i<n;i++)
    {q=new Node;
        q->data=i+1;
            p->next=q;
        p=q;
    }
    p->next=head->next;
}
ListNode * find(ListNode *head,int i)
{        ListNode *p;
    p=head;
    int count=0;
    while(count<i)
    {   
        p=p->next;
        count++;
        
    }
    return p;
}
void yuesehu(ListNode *head)
{    ListNode *p,*pre,*t;
    p=head;
    int m,k;
        cout<<"起始报数的猴子编号k:"<<endl;
    cin>>k;
    cout<<"出局数字m:"<<endl;
    cin>>m;
    p=find(p,k-1);
    cout<<"猴子的出队序列:"<<endl;
    while(p!=NULL)
    {    for(int j=0;j<m;j++)
        {    pre=p;
                p=p->next;
        }
        cout<<p->data<<" ";
            if(pre!=p)
        {    t=p;
                pre->next=p->next;
                p=p->next;
                p=pre;
                delete t;
            }
            else
            {    delete pre;
                p=NULL;
            }
    }
}
int main()
{    ListNode *l,*p;
    l=new Node;
    int i,c;
    Create(l);
    yuesehu(l);
    cout<<endl;
    return 0;
}

这是一道算法与数据结构题目，我下面写一下我的思路。
1、建立一个头指针，后续的结点数据域是number，password。
2、接下来是定义一系列的链表基本操作，如：initlist（初始化链表），Dellist（删除链表中的结点）。
3、将建立好的链表一一输出。
4、编写实现约瑟夫环问题的函数。
对于那个m，我是想让环内的人一一报数，当数到m时，输出这个人的号码与密码，然后删除这个结点，再让这个人的密码为这个m值，重复操作，直至链表删除完毕。
看了一下你的程序，为什么在主函数里面要定义一个指针p和整型变量c、i但后面又没有去用它，还有为甚么要又申请一个结点。我想应该是多余的吧，还是你输入错了？
最后谢谢你啊！

那个c，i是以前测试find();函数用的，忘了删了，可以删了的没有用的。那个指针p也是多余的。申请一个节点是为了初始化一个头节点和你那个初始化函数作用相同。
输入输出我给你改好了，就是那个第4步没看明白。输出这个人的号码与密码，然后删除这个结点，再让这个人的密码为这个m值，表示节点都删除了，怎么让他的密码为m，真不明白。再说明下好不

循环链表果断错了，我昨天刚做的实验   你看看

#include<stdio.h>
#include<malloc.h>

typedef struct Node
{   
    int data;
    int pasword;
    struct Node *next;
}LinkList;

LinkList *creat(int n)
{
    LinkList *p,*q,*L;
    int i=1;
    L=p=(LinkList *)malloc(sizeof(LinkList));
    p->data=i;
    printf("第1个人的密码:");
    scanf("%d",&p->pasword);
    for(i=2;i<=n;i++)
    {
        q=(LinkList *)malloc(sizeof(LinkList));
        if(q==0) return 0;
        printf("第%d个人的密码:",i);
        scanf("%d",&q->pasword);
        q->data=i;
        p->next=q;
        p=q;   
    }
    p->next=L;
   return L;
}

void fun(LinkList *L)
{
    int m,i;
    LinkList *p=L,*q,*s;
    printf("请输入初始m值:");
    scanf("%d",&m);
    printf("出列顺序为:");
    while(p->next!=p)
    {
        for(i=1;i<m;i++)
        {    q=p;
            p=p->next;
        }
        printf("%5d",p->data);
        m=p->pasword;
        s=p;
        q->next=p->next;
        p=p->next;
        free(s);
    }
    printf("%5d",p->data);
    printf("\n");
}

main()
{    LinkList *L;
    int n;
    printf("输入实验人数:");
    scanf("%d",&n);
    L=creat(n);
    fun(L);   
    return 0;
}

 

没有错吧，谢谢你啦，我终于明白楼主得意思啦。

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

typedef struct node
{
    int number;
    int password;
    struct node *next;
}person;
typedef person *personlist;
/* 得到一个头指针 */

void initlist(personlist *l)
{
   
    (*l)=(person*)malloc(sizeof(person));        /* 得到一个头结点 */
    (*l)->next=(*l);                            /* 让该链表为一条循环单链表 */
}
/* 初始化链表 */

int Dellist(personlist p,int *s)                /* p代表当前指针指向的结点，s是为了给m重新赋值 */
{
    person *r;
    int t;
               
    r=p->next;
    t=r->number;
    *s=r->password;                                /* 将m的值改为被删除的人的密码 */

    p->next=r->next;
    free(r);                                    /* 删除结点 */
   
    return t;
}
/* 删除链表中与e相等的值 */

int createlist(personlist l)
{
    person *p,*s;
    int i=1,y;            /* 让i和y分别赋值给结点上的号码与密码 */

    int x;
   
    p=l;

    printf("请输入人数:");
    scanf("%d",&x);
    for(int n=0;n<x;n++)
    {
        p=p->next;
        s=(personlist)malloc(sizeof(person));
        printf("请输入第%d个人的密码:",i);
        scanf("%d",&y);

        s->number=i;
        s->password=y;
        
        p->next=s;
        s->next=l;                    /* 让末尾结点指针指向头结点，构成循环链表 */

        i++;
    }   
    return n;
}
/* 成功建立了一个链表 */

void showlist(personlist l,int k)
{
    person *p;
    p=l->next;
   

    printf("输出原始序列\n");

    for(int n=1;n<=k;n++)
    {
        printf("%d,%d\n",n,p->password);
        p=p->next;
    }
}
/* 为了检验，输出所有人的密码 */

void yuesefu(person* l,int m)
{
    person *p;
    p=l;

    int t;

    printf("显示出列顺序:\n");

    while( l->next != l )
    {
        for(int i=1;i<m;i++)
        {
            if(p->next==l)        /* 头结点不能报数 */
            {   
                p=p->next;
            }

            p=p->next;

            if(p->next==l)        /* 头结点不能删除 */
            {
                p=p->next;
            }
        }

            t=Dellist(p,&m);
            
            printf("出列:%d\n",t);
            
            printf("新密码：%d\n",m);
    }
}
/* 让指针在链表上移动并查找与m相匹配密码的人，输出且将其删除 */

int main()
{
    personlist l=NULL;
    initlist(&l);

    int y;
    y=createlist(l);

    showlist(l,y);

    int x;
   
    printf("请输入初始密码:");
    scanf("%d",&x);

    yuesefu(l,x);

    return 0;
}
/* 编写主函数 */
修改了原先的程序，真的错误很多，现在能够通过了。
这里我先列出来需要注意的地方：1、其实我原先在调用Initlist函数时，调用错了，应把主函数定义的指针l地址传给形参；
                              2、建立循环链表时每新建一个结点都应将该结点指回头结点；
                              3、yuesefu函数中前面的for循环挺难想的，这是别人教的。
最后希望二楼再看一下，应该就可以明白你原先的疑问了。

约瑟夫环（Josephus）问题的求解
具体描述是：设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第K个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。
请根据以上描述，选择合适的存储结构，完成约瑟夫环的求解。请打印出圈人的序号。怎么改这个呢，谢谢！
#include<stdio.h>
#define MaxSize 100
typedef int DataType;
#include"SeqLin.h"

void main()
{
    SeqList mylist;
    int i,j,m,n,k,x;
    ListInitiate(&mylist);
    printf("请输入总共有几个人:");
    scanf("%d",&n);
    printf("请输入从第几个人开始:");
    scanf("%d",&k);  
    printf("请输入数到几个人出来:");
    scanf("%d",&m);


    for(i=0;i<n;i++)
    ListInsert(&mylist,i,i+1);

    for(i=0;i<n;i++)
    {
        printf("%d ",mylist.list[i]);
     
    }
    printf("\n");

printf("输出出列顺序:");

j=0;
for(i=k-1;mylist.size>1;i++)
{
    j++;
    if(j==m)
        {
            x=mylist.list[i];
            ListDelete(&mylist,x);
            printf("%d ",x);
            j=0;
            i--;
        }
    if(i==mylist.size)
        i=0;
}
        printf("\n");
        printf("请输入剩下最后的那一位人:");
        for(i=0;i<mylist.size;i++)
        printf("%d",mylist.list[0]);
        printf("\n");
}
头文件如下：
typedef struct
{
    DataType list[MaxSize];            
    int size;
} SeqList;

void ListInitiate(SeqList *L)            /*初始化顺序表L*/
{
    L->size = 0;                    /*定义初始数据元素个数*/
}
int ListInsert(SeqList *L, int i, DataType x)
/*在顺序表L的位置i（0 ≤ i ≤ size）前插入数据元素值x*/
/*插入成功返回1，插入失败返回0*/
{
    int j;
    if(L->size >= MaxSize)
    {
        printf("顺序表已满无法插入! \n");
        return 0;
    }
    else if(i < 0 || i > L->size )
    {
        printf("参数i不合法! \n");
        return 0;
    }
    else
    {
        for(j = L->size; j > i; j--) L->list[j] = L->list[j-1];        /*为插入做准备*/
        L->list[i] = x;                                    /*插入*/
        L->size ++;                                    /*元素个数加1*/
        return 1;
    }
}

int ListDelete(SeqList *L,DataType x)
{
    int i,j;
    for(i=0;i<L->size;i++)   
    if(x == L->list[i]) break;
            if(i==L->size)    return 0;
            else
            {
                for(j=i;j<L->size-1;j++)
                    L->list[j]=L->list[j+1];
                    L->size--;
                    return 1;
            }


}