A. c语言 约瑟夫环问题：用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。
帮你改了程序
#include <stdafx.h>
#include <stdlib.h>
struct number
{
int num;
struct number * next;
};
void main ()
{
int m, n;
struct number * p, * head=NULL, * tail;
printf("please input M and N:\n");
scanf("%d %d", &m, &n); //输入M、N值。
for (int i=1; i<=n; i++) //建立循环链表。
{
p=(struct number *)malloc(sizeof(struct number));
p->num=i;
if(head==NULL){
head=p;
tail=p;//注意开始tail也要赋值
}
else
tail->next=p;
tail=p;
}
tail->next=head;
p = tail; //从head开始，记录开始的前一个指针
while(n--) //剩下的数的个数为n
{ int t = m%n; //防止多数太多圈造成时间浪费
for(int j=1; j<t;j++ ) //数到要删的那个数的前一个
p=p->next;
number *q = p->next; //要删的数的指针
printf("%d ", q->num); //输出要删的数
p->next = q->next; //要删的数从链表中去掉
free(q);
}
printf("\n");
}
B. 约瑟夫环（c语言）
怎么了，代码看不懂？
约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后结果+1即为原问题的解。
首先我们列出一些有关约瑟夫环的结果：
1 1 2 2 3 2 4 1 5 4 6 1 7 4 8 7 9 1 10 4
11 7 12 10 13 13 14 2 15 5 16 8 17 11 18 14 19 17 20 2021 2 22 5 23 8 24 11 25 14 26 17 27 20 28 23 29 26 30 29
31 1 32 4 33 7 34 10 35 13 36 16 37 19 38 22 39 25 40 28
41 31 42 34 43 37 44 40 45 43 46 46 47 2 48 5 49 8 50 11
51 14 52 17 53 20 54 23 55 26 56 29 57 32 58 35 59 38 60 41
61 44 62 47 63 50 64 53 65 56 66 59 67 62 68 65 69 68 70 171 4 72 7 73 10 74 13 75 16 76 19 77 22 78 25 79 28 80 31
81 34 82 37 83 40 84 43 85 46 86 49 87 52 88 55 89 58 90 61
91 64 92 67 93 70 94 73 95 76 96 79 97 82 98 85 99 88 100 91
意思是，前一个数为约瑟夫环的人数，后一个数为最后出去的人的号码。
从上面的表中我们可以归纳出以下两个规则：
规则1:若上一组数字中最后保留号比人数少一，则下一数从1开始记。
例如第三组（3,2）为上一组，最后保留好为2，比3少1，下一组的数字（4,1），最后保留号为1
规则2:若上一组数字为最后保留号与人数相等，则下一数从2开始记。
C. 约瑟夫环问题 c语言程序
已经修改好了。上次调试程序调试的不仔细，这次应该没问题了，如果有的话再跟我联系。
#include<stdio.h>
#defineS()sizeof(structquene)
typedefstructquene
{intn;
structquene*next;
}QUE;
QUE*fun1(intn);
intfun2(QUE*p);
intmain()
{intm,i,n,j,s;
QUE*p,*p2;
printf("n=");
scanf("%d",&n);
printf("m=");
scanf("%d",&m);
printf("i=");
scanf("%d",&i);
p=fun1(n);
for(j=1;j<i;p=p->next,j++);
j=1;p2=p;
while((p->next)!=p)
{p=p->next;
if(++j==m)
{j=1;p=p->next;
s=fun2(p2);
printf("%d",s);
}
p2=p;
}
printf("%d ",p->n);
}
QUE*fun1(intn)
{QUE*head,*p1,*p2;
inti;
for(i=1;i<=n;i++)
{p1=(QUE*)malloc(S());
if(i==1)head=p1;
elsep2->next=p1;
p1->n=i;
p2=p1;
}
p1->next=head;
returnhead;
}
intfun2(QUE*p)
{QUE*p2;
intn;
p2=p->next;
n=p2->n;
p->next=p2->next;
free(p2);
returnn;
}
D. 关于循环队列实现约瑟夫环（C语言）的问题
首先，p是指向头结点的，或者说第一个结点，然后：
p->next = p; //p->next也指向头结点，也就是头结点的next指向自己，那么一开始只有一个结点时这就已经是一个循环链表了，后面再插入结点时只要尾结点的next指向头结点，就能保持它仍然是循环链表。
node *r = p;//用r来指向尾结点，r=p，因为p->next=p，所以也就是r->next==p，尾结点的next指向头结点。
for循环中：
q->next = r->next;//把新增结点的next指向头结点，其实等价于q->next=p，因为r->next==p，尾结点的next是指向头结点的。
r->next = q;//把原先的尾结点的next指向新增结点。
r = q;//把尾结点改为新增结点，因为上面已经将新增结点的next指向头结点，所以这个操作过后，尾结点的next仍然指向头结点，也就保持了链表仍然是循环链表。
E. C语言约瑟夫问题
约瑟夫问题：
#include<iostream.h>
struct
node
{
int
data;
node
*pnext;
};
void
main()
{
int
n,k,m,i;
node
*p,*q,*head;
cout<<"输入n的值:";
cin>>n;
cout<<"输入起始报数人号码k的值:";
cin>>k;
cout<<"输入
数到m出列的m的值:";
cin>>m;
head=(node*)new
node;
//确定头结点
p=head;
for(i=1;i<=n-1;i++)
//赋初值
{
p->data=i;
p->pnext=(node*)new
node;
//为下一个新建内存
p=p->pnext;
}
p->data=n;
//最后一个单独处理
p->pnext=head;
//指向头，形成循环链表
p=head;
while(p->data!=(p->pnext)->data)
//p->data==(p->pnext)->data表示只剩下一个结点的
{
while(p->data
!=k)
//寻找编号为k的结点
p=p->pnext;
if(m==1)
{
for(i=1;i<=n;i++)
{
cout<<p->data<<'\\t'
;
p=p->pnext
;
}
cout<<'\
';
return;
}
else
for(i=1;i<m-1;i++)
//开始报数
{p=p->pnext;}
//找到报m-1的结点
q=p->pnext;
//q为报m的结点
cout<<q->data<<"\\t";
//输出报m的结点的值
k=(q->pnext)->data;
//k为下一个报数的起点
p->pnext=q->pnext;
//删除报m的结点
}
cout<<p->data<<'\
';
//输出最后一个结点的值
}
F. 用循环队列实现约瑟夫环处理。若干人循环报数，凡报到3的倍数退出，最后剩下的一个人是第几人
// 首先确认n个人，并打上标记
int n = 10;
// 退出的报数数字
int say = 3;
Queue<Integer> qu = new LinkedList<Integer>();
for (int i = 0; i < n; i++) {
qu.add(i + 1);
}
// 开始报数技术
int j = 1;
int lastMan = 0;
while (qu.size() > 0) {
lastMan = qu.poll();
if (j % say == 0) {
j = 0;
} else {
qu.add(lastMan);
}
j++;
}
System.out.println(lastMan);
G. 求用循环队列解决约瑟夫环问题的C语言代码，急，速度！！！！！！！
他们都是用链表做的。。我没用链表做。。。很简单的写了一个。。。
#include<iostream.h>
voidFmade(intx,inty,intz);
voidmain()
{
inta,b,c;
//ti,j,k;
//taa[100],b[100];
cout<<"请输入总人数：";
cin>>a;
cout<<endl<<"请输入开始位子：";
cin>>b;
cout<<endl<<"请输入步长：";
cin>>c;
Fmade(a,b,c);
}
voidFmade(intx,inty,intz)
{
inti,j=0,k=0;
intaa[100],bb[100];
intstart;
aa[0]=0;
for(i=1;i<=x;i++)
{
aa[i]=i;
}
start=y;
while(j<x)
{
while(start<=x)
{
if(aa[start]!=0)
{
k++;
}
if(k==z)
{
bb[j]=aa[start];
aa[start]=0;
j++;
k=0;
}
start++;
}
start=1;
}
cout<<"出列顺序为：";
for(i=0;i<x;i++)
{
cout<<bb[i]<<"";
}
}
说明下：因为这个数组只定义了100个字节。其中第一字节没有用。。所以只能计算99以内的出列。。。包括99，如果需要扩大计算范围，只需要扩大数组长度就行了。。。也就Fmade函数的定义。。。
最够插入运算的答案的图片：
H. 关于约瑟夫环的问题 c++循环队列实现
给，已经编译运行确认：
#include <iostream.h>
#include <stdlib.h>
typedef struct Node
{
int data;
struct Node* next;
}LNode, *LinkList;
LinkList list = NULL;
int n; //人数
int m; //报数号
//n为总人数，k为第一个开始报数的人，m为出列者喊到的数
void JosephRing(int n, int k, int m)
{
LinkList p, r; /* p为当前结点,r为辅助结点，指向p的前驱结点*/
for(int i = 1; i <= n; i++) /*建立循环队列*/
{
p = (LinkList)malloc(sizeof(LNode));
p->data = i;
if(list == NULL) list = p;
else r->next = p;
r = p;
}
p->next = list; /*使队列循环起来*/
p = list; /*使p指向头节点*/
/*把当前指针移动到第一个报数的人*/
for(i = 1; i < k; i++)
{
r = p;
p = p->next;
}
/*循环地删除队列结点*/
while(p->next != p)
{
for(i = 1; i < m; i++)
{
r = p;
p = p->next;
}
r->next=p->next;
cout<<p->data<<endl;
free(p);
p=r->next;
}
cout<<endl<<"最终剩下的人为: "<<p->data<<endl;
}
int main()
{
int m,n,i;
cout<<"请输入人数n: ";
cin>>n;
cout<<"请输入开始位置i: ";
cin>>i;
cout<<"请输入报数m: ";
cin>>m;
cout<<"出队顺序如下: "<<endl;
JosephRing(n, i, m);
system("pause");
return 1;
}
I. 求一个，循环队列解决约瑟夫环问题的C语言程序，谢谢
正好我以前写的这个还留着，如下：
n为人数，m是初始随机数
#include<stdio.h>
int main(void)
{
int m,n,i,j,k,times,num,a[2][100],b[100];
scanf("%d %d",&n,&m);
k=0;
if(n>0&&n<100)
{
for(num=1;num<n+1;num++)
{
scanf("%d",&a[0][num]);
a[1][num]=1;
}
for(j=0,i=1,times=1;times<=n;i++)
{
if(a[1][i]==1)
j++;
else
;
if(j==m)
{
a[1][i]=0;
j=0;
m=a[0][i];
b[k]=i;
k++;
times++;
}
if(i>=n)
i=0;
}
for(num=0;num<n;num++)
printf("%d ",b[num]);
}
return 0;
}
J. 约瑟夫环用C循环链表解
约瑟夫环问题的参考程序：
#include "stdio.h"
#include "stdlib.h"
typedef struct node
{ int data;
struct node *next;
}JD;
JD *xhlbjl(JD *front, JD *rear,int n)
{ /*建立循环队列*/
int i;
front=(JD *)malloc(sizeof(JD));
front->data=n; /*头指针指向n号*/
front->next=front;
for (i=n-1;i>0;i--)
{ rear=(JD *)malloc(sizeof(JD));
rear->data=i;
rear->next=front->next;
front->next=rear;
}
return(front);
}
JD *outqueue(JD *front, JD *rear,int m) /*出队列*/
{int i,s;
for (i=0;i<s-1;i++)
front=front->next;
return(front);
}
main()
{ JD *h,*p,*q,*s;
int i,j,m,n;
printf("请输入人数 ");
scanf("%d",&n);
h=xhlbjl( p,q,n);
p=h->next;
printf("坐成一圈的人是: ");
for(i=1;i<=n;i++)
{ printf("%3d",p->data);
p=p->next;
}
printf("\n请输入开始位置 ");
scanf("%d",&s);
printf("数几个出去 ");
scanf("%d",&m);
s=outqueue(p,q,m);
q=s;
p=s->next;
for(j=0;j<n;j++)
{ for (i=1;i<m;i++)
{ q=p;
p=p->next;
}
printf("\n出列的人是第 %d 号",p->data);
q->next=p->next;
free(p);
p=q->next;
}
}