求解约瑟夫问题的递归算法

[冰河zyc]

谁有约瑟夫问题的递归算法？
得到出列的顺序。

[jinjiajie]

...今天是第几次看到这个问题了

[syd1207]

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

#define MAX_NODE_NUM 100
#define TRUE 1U
#define FALSE 0U

typedef 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;
}
else
break;
}

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;
}
/***********************************************
第一组测试结果
人数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个人出列, 密码: 9
***********************************************/

[冰河zyc]

楼上的不是递归算法吧

[jixingzhong]

一个简单的例子：

/*约瑟夫环*/

#include <stdlib.h>
#include <stdio.h>
typedef struct node
{
int data;
struct node *next;
}LNode;

main()
{
LNode* Create(int,int);
LNode* GetNode(LNode *);
int Print(LNode *,int);
LNode *p;
int n,k,m;
do
{
printf ("输入总人数");
scanf ("%d",&n);
}
while (n<=0);
do
{
printf ("输入开始人的序号(1~%d)",n);
scanf ("%d",&k);
}
while (k<=0 || k>n);
do
{
printf ("输入间隔数字");
scanf ("%d",&m);
}
while(m<=0);

p=Create(n,k);
Print(p,m);
return 0;
}；

LNode* Create(int n,int k)/*创建循环链表*/
{
int start=k-1;
LNode *s,*p,*L=0,*t;
if (start==0) start=n;
while (n!=0)
{
s=(LNode *)malloc(sizeof(LNode));
if (L==0) p=s;
if (n==start) t=s;
s->data=n;
s->next=L;
L=s;
n--;
}
p->next=L;
return t;
}

LNode* GetNode(LNode *p)/*出队函数*/
{
LNode *q;
for (q=p;q->next!=p;q=q->next);
q->next=p->next;
free (p);
return (q);
}

Print(LNode *p,int m)/*输出函数*/
{
int i;
printf ("出队编号:\n");
while (p->next!=p)
{
for (i=1;i<=m;i++)
p=p->next;
printf ("%d ",p->data);
p=GetNode(p);
}
printf("%d\n",p->data);
return 0;
}

[冰河zyc]

大家看清楚了是用递归

[du51]

#include<iostream>
using namespace std;
//本程序以从1开始数,数到3离队为例,其它情况只用少加修改
void make(int *base,int n,int pos,int c)
{
int j=0;
cout<<"NO. "<<++c<<" 第"<<pos+1<<"位出列"<<endl;//输出
base[pos]=0;//踢掉
if(c==n)return; //出口
while(j-3)if(base[pos=(pos+1)%n])j++;//递归点 ,每次数到几这个3就改到几
make(base,n,pos,c);//递归
}
int main()
{
int n,c=0,pos=2;//从N开始数,则把pos改为N-1就行了.
cout<<"请输入总人数"<<endl;
cin>>n;
int *base=new int[n];
for(int i=0;i<n;i++)base[i]=1;
make(base,n,pos,c);
delete[]base;
system("PAUSE");
return 0;
}

[du51]

刚才我也回了一个这样的问题.怎么不见了!!!