(约瑟夫问题)N个人围成一圈,从第一个开始报数,第k个退出,再从1开始报数,依次循环,直到最后一个人
从第s(sn)个人开始报数,数到m的人出圈;再由下一个人
1．约瑟夫问题：n个人围成一圈，从第s（s<n）个人开始报数，数到m的人出圈；再由下一个人开始报数，数到m的人出圈；……。
输出依次出圈的人的编号。
m的值预先选定，n由键盘输入。
分析：我们将这n个人组成一个链表，表中每一个元素为一记录类型，第一个域变量lvalue为人的编号，第二个域变量next指向下一个人，这样链接下去构成一个环形链。
然后由lvalue值为s的记录开始，对链中的元素逐一记数，数到第m个记录时，将它删去，即把第（m-1）个记录的指针改成指向第（m+1）个记录，然后从第（m+1）个向下记数，这样重复进行下去，直到剩下一个记录。
出列的人也组成一条链，r是其首指针，只要打印这条链就得到结果。
源程序如下：#include <iostream.h>#include <stdio.h>#include <stdlib.h> // 使用malloc()函数的库函数#include <malloc.h>typedef struct linknode{int lvalue;struct linknode *next;} point;int main(){int n,m,s,node,i;point *p,*q,*r;cout<<"Input total number, initial number and distance: ";cin>>n>>s>>m;p=(point *)malloc(sizeof(point));q=p;for(i=1; i<=n-1; i++){ // 生成链表q->lvalue=s;s=s%n+1;q->next=(point *)malloc(sizeof(point));q=q->next;}q->lvalue=s;q->next=p; // 生成循环链表node=n;r=(point *)malloc(sizeof(point));q=r;while(node>1){if(m==1){r->next=p;node=1;}else{for(i=1; i<=m-2; i++)p=p->next;q->next=p->next; // 将数到m的人出圈，链到出列人的链表中q=q->next;p->next=p->next->next;p=p->next;node--;}}for(i=1; i<=n-1; i++){ // 依次打印出列人的序号r=r->next;cout<<"The"<<i<<"th person is number:"<<r->lvalue<<endl;}if(m==1)cout<<"The last one is number:"<<r->next->lvalue<<endl;elsecout<<"The last one is number:"<<p->lvalue<<endl;return 1;}2．设单链表中存放着n个字符，试设计算法判断字符串是否中心对称。
约瑟夫效应的原理与应用
约瑟夫效应的原理与应用简介约瑟夫效应（Josephus problem）是一个著名的数学问题和游戏，也被称为约瑟夫斯问题。
问题描述如下：假设有n个人围成一圈，从某个人开始报数，报到m的人出列，接着从出列的下一个人开始重新报数，直到最后只剩下一个人为止。
问题的关键是确定最后剩下的这个人在最初的位置。
约瑟夫问题的解法有很多，包括数学推导和编程算法等。
原理解析约瑟夫效应的原理可以用数学计算来解释。
假设有n个人围成一圈，从第一个人开始报数，每报到m的人出列。
假设第一个出列的人的位置是k，我们可以推导出第二个出列的人的位置是(k+m-1)%n，第三个出列的人的位置是(k+m-1+m-1)%n，以此类推。
最后剩下的那个人的位置就是从1开始数的序号。
应用场景虽然约瑟夫问题看似只是个数学问题或游戏，但实际上它在很多实际场景中都有应用。
下面列举几个常见的应用场景：1.编程算法约瑟夫问题可以用于编程算法的设计与困难的解决。
例如，给定一个数组，要求按照某种规则删除元素，直到最后只剩下一个元素。
这个问题可以通过约瑟夫问题的解决思路来解决。
2.网络协议在一些分布式系统中，节点之间需要按照某种规则进行通信。
约瑟夫问题的解决思路可以用于设计节点间的通信协议，确保每个节点都能按照规则顺序接收到消息。
3.人员调度在一些团队或组织中，需要对人员进行轮换、调度或排班工作。
约瑟夫问题的解决思路可以用于确定轮换、调度或排班的规则，确保公平公正。
编程实现约瑟夫问题的解决方法有很多，其中一种常见的实现方式是使用循环链表。
具体的算法如下：```python def josephus(n, m): # 创建循环链表 circle = [i for i in range(1, n+1)]idx = 0while len(circle) > 1:# 找到要删除的位置idx = (idx + m - 1) % len(circle)# 删除该位置上的元素del circle[idx]return circle[0]测试n = 10 m = 3 result = josephus(n, m) print(。
实验一：约瑟夫问题
实验一：约瑟夫问题问题描述：用数组和链表存储方式实现约瑟夫问题。
约瑟夫问题：n个人围成一个圆圈，首先第1个人从1开始一个人一个人顺时针报数，报到第m个人，令其出列。
然后再从下一个人开始，从1顺时针报数，报到第m个人，再令其出列，…，如此下去，直到圆圈中只剩一个人为止。
此人即为优胜者。
基本要求：用顺序存储和链式存储方式实现。
试验报告内容：1．问题描述：设有n个人围坐在圆桌周围，现从某个位置m（1≤m≤n）上的人开始报数，报数到k 的人就站出来。
下一个人，即原来的第k+1个位置上的人，又从1开始报数，再报数到k的人站出来。
依此重复下去，直到全部的人都站出来为止。
2. 算法描述：可以先建一个单向循环链表；而整个“约瑟夫环”问题的过程，最终是把这个链表删空为止。
但在删时不能顺着删，而是按该问题的方案来删。
3.源程序#include <stdio.h>#include <stdlib.h>#define MAX_NODE_NUM 100#define TRUE 1U#define FALSE 0Utypedef struct NodeType{int id; /* 编号 */int cipher; /* 密码 */struct NodeType *next;} NodeType;/* 创建单向循环链表 */static void CreaList(NodeType **, const int);/* 运行 "约瑟夫环 "问题 */static void StatGame(NodeType **, int);/* 打印循环链表 */static void PrntList(const NodeType *);/* 得到一个结点 */static NodeType *GetNode(const int, const int);/* 测试链表是否为空, 空为TRUE，非空为FALSE */static unsigned EmptyList(const NodeType *);int main(void){int n, m;NodeType *pHead = NULL;while (1){printf( "请输入人数n（最多%d个）: ", MAX_NODE_NUM); scanf( "%d ", &n);printf( "和初始密码m: ");scanf( "%d ", &m);if (n > MAX_NODE_NUM){printf( "人数太多，请重新输入！\n ");continue;}elsebreak;}CreaList(&pHead, n);printf( "\n------------ 循环链表原始打印 -------------\n "); PrntList(pHead);printf( "\n-------------- 出队情况打印 ---------------\n "); StatGame(&pHead, m);printf( "\n\ "约瑟夫环\ "问题完成!\n ");return 0;}static void CreaList(NodeType **ppHead, const int n){int i, iCipher;NodeType *pNew, *pCur;for (i = 1; i <= n; i++){printf( "输入第%d个人的密码: ", i);scanf( "%d ", &iCipher);pNew = GetNode(i, iCipher);if (*ppHead == NULL){*ppHead = pCur = pNew;pCur-> next = *ppHead;}else{pNew-> next = pCur-> next;pCur-> next = pNew;pCur = pNew;}}printf( "完成单向循环链表的创建!\n ");}static void StatGame(NodeType **ppHead, int iCipher){int iCounter, iFlag = 1;NodeType *pPrv, *pCur, *pDel;pPrv = pCur = *ppHead;/* 将pPrv初始为指向尾结点，为删除作好准备 */while (pPrv-> next != *ppHead)pPrv = pPrv-> next;while (iFlag) /* 开始搞了! */{/* 这里是记数，无非是移动iCipher-1趟指针! */for (iCounter = 1; iCounter < iCipher; iCounter++) {pPrv = pCur;pCur = pCur-> next;}if (pPrv == pCur) /* 是否为最后一个结点了 */iFlag = 0;pDel = pCur; /* 删除pCur指向的结点，即有人出列 */pPrv-> next = pCur-> next;pCur = pCur-> next;iCipher = pDel-> cipher;printf( "第%d个人出列, 密码: %d\n ",pDel-> id, /* 这个编号标识出列的顺序 */pDel-> cipher);free(pDel);}*ppHead = NULL; /* 没人了！为了安全就给个空值 */}static void PrntList(const NodeType *pHead){const NodeType *pCur = pHead;if (EmptyList(pHead))return;do{printf( "第%d个人, 密码: %d\n ", pCur-> id,pCur-> cipher); pCur = pCur-> next;} while (pCur != pHead);}static NodeType *GetNode(const int iId, const int iCipher){NodeType *pNew;pNew = (NodeType *)malloc(sizeof(NodeType));if (!pNew){printf( "Error, the memory is not enough!\n ");exit(-1);}pNew-> id = iId;pNew-> cipher = iCipher;pNew-> next = NULL;return pNew;}static unsigned EmptyList(const NodeType *pHead){if (!pHead){printf( "The list is empty!\n ");return TRUE;}return FALSE;}4.实验测试数据（要求有多组）：第一组测试结果人数n为7, 初始密码m为20第1个人, 密码: 3第2个人, 密码: 1第3个人, 密码: 7第4个人, 密码: 2第5个人, 密码: 4第6个人, 密码: 8第7个人, 密码: 4-------------- 出队情况打印 ---------------第6个人出列, 密码: 8第1个人出列, 密码: 3第4个人出列, 密码: 2第7个人出列, 密码: 4第2个人出列, 密码: 1第3个人出列, 密码: 7第5个人出列, 密码: 4第二组测试结果人数n为8, 初始密码m为15第1个人, 密码: 5第2个人, 密码: 4第3个人, 密码: 3第4个人, 密码: 2第5个人, 密码: 9第6个人, 密码: 1第7个人, 密码: 7第8个人, 密码: 8-------------- 出队情况打印 ---------------第7个人出列, 密码: 7第6个人出列, 密码: 1第8个人出列, 密码: 8第3个人出列, 密码: 3第1个人出列, 密码: 5第4个人出列, 密码: 2第2个人出列, 密码: 4第5个人出列, 密码: 95.总结：1. 通过本次上机实践,对链表存储结构有了更深的理解和把握.2. 通过本次上机实践,应用链表的知识解决和分析问题的能力有了新的提高.3. 通过上机实践,掌握了用高级语言实现算法的基本步骤和方法.（最前面加班级、学号、姓名）。
约瑟夫问题多种解决方法
• • • • • • • • • • •
s:=0; while s<n do begin if j<m then inc(j) else j:=1; s:=s+a[j]; end; write(j); a[j]:=0; end; end.
约瑟夫问题多 种解决方法
约瑟夫问题的来历
• 据说著名犹太历史学家 Josephus有过以下的故事：在罗 马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋 友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓 到，于是决定了一个自杀方式，41个人排成一个圆圈，由 第1个人开始报数，每报数到第3人该人就必须自杀，然后 再由下一个重新报数，直到所有人都自杀身亡为止。然而 Josephus 和他的朋友并不想遵从，Josephus要他的朋友 先假装遵从，他将朋友与自己安排在第16个与第31个位置， 于是逃过了这场死亡游戏。17世纪的法国数学家加斯帕在 《数目的游戏问题》中讲了这样一个故事：15个教徒和15 个非教徒在深海上遇险，必须将一半的人投入海中，其余 的人才能幸免于难，于是想了一个办法：30个人围成一圆 圈，从第一个人开始依次报数，每数到第九个人就将他扔 入大海，如此循环进行直到仅余15个人为止。问怎样排法， 才能使每次投入大海的都是非教徒。
著名约瑟夫问题一
• 17世纪的法国数学家加斯帕在《数目的游戏问题》中讲了 这样一个故事：15个教徒和15 个非教徒在深海上遇险， 必须将一半的人投入海中，其余的人才能幸免于难，于是 想了一个办法：30个人围成一圆圈，从第一个人开始依次 报数，每数到第九个人就将他扔入大海，如此循环进行直 到仅余15个人为止。问怎样排法，才能使每次投入大海的 都是非教徒。题目中30个人围成一圈，因而启发我们用一 个循环的链来表示。可以使用结构数组来构成一个循环链。 结构中有两个成员，其一为指向下一个人的指针，以构成 环形的链；其二为该人是否被扔下海的标记，为1表示还 在船上。从第一个人开始对还未扔下海的人进行计数，每 数到9时，将结构中的标记改为0，表示该人已被扔下海了。 这样循环计数直到有15个人被扔下海为止
实验一、约瑟夫问题
实验一：约瑟夫问题求解一、问题描述1、实验题目：约瑟夫（Josephus）问题的一种描述是：编号为1，2，……，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个正整数作为报数上线值m，从第一个人开始按顺时针方向自1开始报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向下一个人开始重新从1报数，如此下去，直至所有的人全部出列为止。
2、基本要求：试设计一个程序，按出列顺序印出个人编号。
3、测试数据：m的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4。
ｍ的初值为6，正确的出列顺序应为：6，1，4，7，2，3，5。
二、需求分析１、本程序用来求出含有密码的约瑟夫问题，可以输出所有人的出列顺序。
2 、程序运行后显示提示信息，提示用户输入一圈的人数n，接着输入每个人的密码，最后提示输入初始密码。
3、用户输入完毕后，程序自动输出运算结果。
三、概要设计1、设计思路n个人围成一圈，每个人的手中都有一个密码，这个密码决定了下一次报数的上限。
游戏规则：①给定一个初始密码②循环报数，报到密码值的人要出列，依次类推，直到所有的人都出列本程序要求输入的内容：n个人的密码及初始密码；本程序要求输出的内容：n个人出列的顺序。
2、数据结构为了实现上述功能，可以采用链式存储结构。
采用链式存储结构，定义了一个存储个人信息的结构体，及两个自定义函数，分别用于创建链表和约瑟夫出列操作。
①链表抽象数据类型的定义： #define SLNODE struct slnodeADT SLNODE{数据对象：D={ i a |i a ∈SLNODE, i=1,2,3.... }数据关系：R=φ}ADT SLNODE;②自定义函数:void create_SLnode(SLNODE *p,int n)//创建队列{ 创建链表，为N 个人分配密码 }void Josef(SLNODE *p,int n)//进行约瑟夫操作{输入初始密码m;for(){ 将出列的结点删除，并输出出列序号；}}③本程序的保护模块：结构体模块主程序模块自定义函数模块调用关系：3、程序设计主要算法的流程图：create_SLnode( )算法流程图Josef( )算法流程图四、详细设计1、元素类型、结点的类型及指针#define SLNODE struct slnodeSLNODE//每个结点的结构体{int num;//num代表序号int code;//code代表密码SLNODE *next;};2、自定义函数：void create_SLnode(SLNODE *p,int n)//创建队列，并将其尾指针指向第一个序号{SLNODE *r,*s;s=p;int i,m;cout<<"请给这"<<n<<"个人分配密码："<<endl;for(i=0;i<n;i++){cout<<"请给第"<<i+1<<"个人输入密码："<<endl;cin>>m;r=(SLNODE *)malloc(sizeof(SLNODE));r->code=m;r->num=i+1;r->next=s->next;s->next=r;s=s->next;}p=p->next;s->next=p;}void Josef(SLNODE *p,int n)//进行约瑟夫操作{p=p->next;int m;int i,j;SLNODE *r;cout<<"请输入初始密码："<<endl;cin>>m;cout<<"依次出列的序号为:"<<endl;for(i=0;i<n-1;i++)p=p->next;for(i=0;i<n-2;i++){for(j=0;j<m-1;j++)p=p->next;cout<<(p->next)->num<<endl;m=(p->next)->code;r=p->next;p->next=r->next;}if(m%2==0)cout<<p->num<<endl<<(p->next)->num<<endl;elsecout<<(p->next)->num<<endl<<p->num<<endl;}3、主函数：int main(){SLNODE *p;int n;cout<<"请输入一圈的人数："<<endl;cin>>n;p=(SLNODE *)malloc(sizeof(SLNODE));p->next=NULL;create_SLnode(p,n);Josef(p,n);return 0;}4、函数的调用关系：主函数main()调用自定义函数void create_SLnode(SLNODE *p,int n);/*创建队列*/与void Josef(SLNODE *p,int n);/*进行约瑟夫操作*/。
猴子选大王问题
这是17世纪的法国数学家加斯帕在《数目的游戏问题》中讲的一个故事：15个教徒和15 个非教徒在深海上遇险，必须将一半的人投入海中，其余的人才能幸免于难，于是想了一个办法：30个人围成一圆圈，从第一个人开始依次报数，每数到第九个人就将他扔入大海，如此循环进行直到仅余15个人为止。
问怎样排法，才能使每次投入大海的都是非教徒。
*问题分析与算法设计约瑟夫问题并不难，但求解的方法很多；题目的变化形式也很多。
这里给出一种实现方法。
题目中30个人围成一圈，因而启发我们用一个循环的链来表示。
可以使用结构数组来构成一个循环链。
结构中有两个成员，其一为指向下一个人的指针，以构成环形的链；其二为该人是否被扔下海的标记，为1表示还在船上。
从第一个人开始对还未扔下海的人进行计数，每数到9时，将结构中的标记改为0，表示该人已被扔下海了。
这样循环计数直到有15个人被扔下海为止。
[编辑本段] 约瑟夫问题的一般形式：约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。
例如N=6，M=5，被杀掉的人的序号为5，4，6，2，3。
最后剩下1号。
假定在圈子里前K个为好人，后K个为坏人，你的任务是确定这样的最少M，使得所有的坏人在第一个好人之前被杀掉。
C++代码示例: #i n c l u d e<i o s t r e a m>u s i n g n a m e s p a c e s t d;v o i d m a i n()i n t n,m,a[101],k,i,j,n um; //计数器是从1开始的,所以100个人用101 c o u t<<"请输入参加游戏的玩家人数(不超过100人):";c i n>>n;c o u t<<"----------------------------------------"<<e nd l;i f(n>100){c o u t<<"玩家太多,请重新登陆此程序!"<<e nd l;r e t u r n;}c o u t<<"输入游戏中要玩的数字:";c i n>>m;c o u t<<"----------------------------------------"<<e nd l;f o r(i=1;i<=n;i++){ a【i】=1;//注意百度百科里不让使用ASCII里的方括号，这里是中文字符集里的方括号，}j=0;k=0;f o r(i=1;i<=n+1;i++){i f(a【i】==1){j=j+a【i】;i f(j==m)j=0;a【i】=0;k++;}i f(k==n){n u m=i;b r e a k;}}i f(i==n+1)i=0;}c o u t<<"最后获胜的玩家是第"<<n u m<<"号玩家!"<<e nd l;c o u t<<"----------------------------------------"<<e nd l;}写完密码约瑟夫就想到原来看到约瑟夫问题的一个数学解法很巧妙很简单不过只能推出最后一个出列的人无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。
约瑟夫问题
• 约瑟夫问题 约瑟夫问题(josephus)
{ 边界： 边界：J(n, k, 1) = (k - 1) mod n 递推式： 递推式：J(n, k, t) = (J(n - 1, k, t - 1) + k) mod n }
约瑟夫问题
• [输出格式 输出格式 输出格式
输出共一行。 输出共一行。 第一行共一个数，即第T个出列的人的编号 个出列的人的编号。 第一行共一个数，即第 个出列的人的编号。
• [样例输入 样例输入] 样例输入
40 2 1 40
• [样例输出 样例输出] 样例输出
17
约瑟夫问题
• [数据范围 数据范围] 数据范围
program ex4_2(input,output); const maxm=100; var i,m,n,count,current,out:integer; monkey:array [1..maxm] of integer; begin write('Input m,n:'); readln(m,n); for i:=1 to m do monkey[i]:=1; out:=0; count:=1; current:=1;
约瑟夫问题
• M只猴子要选大王，选举办法如下：所有猴 子按1…M编号围坐一圈，从第1号开始按顺 序1、2、…、N报数，凡报到N的猴子退出 到圈外，如此循环报数，直到圈内只剩下 一只猴子时，这只猴子就是大王。M和N由 键盘输入，打印出最后剩下的那只猴子的 编号。
约 瑟 夫 环 问 题 的 三 种 解 法
约瑟夫环问题的简单解法（数学公式法）关于约瑟夫环问题，无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。
我们注意到原问题仅仅是要求出最后的胜利者的序号，而不是要读者模拟整个过程。
因此如果要追求效率，就要打破常规，实施一点数学策略。
为了讨论方便，先把问题稍微改变一下，并不影响原意：问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。
求胜利者的编号。
我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k=m%n的人开始）:k k+1 k+2 … n-2, n-1, 0, 1, 2, … k-2并且从k开始报0。
现在我们把他们的编号做一下转换：k-2 – n-2k-1 – n-1解x’ —- 解为x注意x’就是最终的解变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x’=(x+k)%n如何知道(n-1)个人报数的问题的解？对，只要知道(n-2)个人的解就行了。
(n-2)个人的解呢？当然是先求(n-3)的情况—- 这显然就是一个倒推问题！下面举例说明：假设现在是6个人（编号从0到5）报数，报到（2-1）的退出，即 m=2。
那么第一次编号为1的人退出圈子，从他之后的人开始算起，序列变为2,3,4,5,0，即问题变成了这5个人报数的问题，将序号做一下转换：现在假设x为0,1,2,3,4的解，x’设为那么原问题的解（这里注意，2,3,4,5,0的解就是0,1,2,3,4,5的解，因为1出去了，结果还是一个），根据观察发现，x与x’关系为x’=(x+m)%n，因此只要求出x，就可以求x’。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
while(1)
{
printf("请输入总人数n和退出条件k的值\n");
printf("\nn=");
scanf("%d",&n);
printf("\nk=");
scanf("%d",&k);
printf("\n");
head=creat(n);
p=q=head;
if(p->number==k)
{
if(p!=head)
{
q->next=p->next;
free(p);
break;
}
else if(p==head)
{
q->next=p->next;
head=p->next;
break;
}
}
}
return head;
}
main()
{
int n,k,i=0;
int a;
printf("是否需要继续？1(继续) or 0(退出)\n请输入0或1:");
scanf("%d",&a);
system("cls");
if(a==0)
break;
}
}
}
struct ring* delete_number(struct ring *head,int k)
{
struct ring *q,*p;
q=p=head;
if(head==NULL)
{
printf("该链表中无数据元素，不能删除\n");
return head;
}
while(1)
{
q=p;
p=q->next;
q=head=NULL;
while(i<=n)
{
p=(struct ring*)malloc(sizeof(struct ring));
p->number=i;
if(==NULL)
{
head=q=p;
}
else
{
q->next=p;
q=p;
}
i++;
}
q->next=head;
return head;
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
struct ring
{
int number;
struct ring *next;
};
struct ring* creat(int n )
{
struct ring *q,*p,*head;
int i=1;
while(1)
{
q=p;
p=q->next;
i++;
if(i%k==0&&((head->next)!=head))
{
head=delete_number(head,q->number);
}
if((head->next)==head)
break;
if(p->next==head)
i=i%k;
}
printf("最后剩下的人是%d号\n",p->number);