单链表实现约瑟夫环 - 数据结构与算法

问题点数：0 回复次数：3

单链表实现约瑟夫环

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

typedef struct stu
{
    int num;
    int move;
    int pwd;
    struct stu *next;
}Node,*Linklist;

void kong(Linklist &L)
{
    L=(Linklist)malloc(sizeof(Node));
    L->next=NULL;
}

void creat(Linklist &L,int n)
{
    int i;
    Linklist r,s;
    r=L;
      for(i=1;i<=n;i++)
    {
        s=(Linklist)malloc(sizeof(Node));
        s->num=i;
        s->move=i;
        printf("请输入第%d个人的密码：",i);
        scanf("%d",&s->pwd);
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

void huan(Linklist &L,int n,int m)
{
  int out,x,f,j;
  f=x=1;
  Linklist p,h,g,p1,g1;
  p1=L;
  p=L->next;
  g=L->next;
  while(p)
  {

    out=m%n;
    if(out==0) out=n;

    if(p->move==out)
    {
        printf("\n%d",p->num);
           m=p->pwd;
        n--;

        h=p;
        p=p->next;
        free(h);
        if(out==1)
        {
            L->next=p;
        }
        else
        {
        for(;x<f;x++)
            p1=p1->next;

        if(p==NULL)
        {
            p=L->next;
            p1->next=NULL;
        }
        else
        {
          p1->next=NULL;
          L->next=p;
          g1=p;
          while(p->next)
              p=p->next;
          p->next=g;
          g=g1;
        }
        }
        p=L->next;
        for(j=1;j<=n;j++)
        {
          p->move=j;
          p=p->next;
        }
        p=L->next;
        g=L->next;
        x=f=1;
        p1=L;
    }
    else
    {
        p=p->next;
        f++;
    }
  }
}

void main()
{
    Linklist L;
    int m,n;
    printf("上限m=");
    scanf("%d",&m);
    printf("人数n=");
    scanf("%d",&n);
    kong(L);
    creat(L,n);
    huan(L,n,m);
    getch();
    free(L);
}

搜索更多相关主题的帖子: 约瑟夫　单链　 int　Linklist　Node　

第 2 楼

得分:0

这个单链表的方法比较好实现...不过在效率上不太好...如果不需要输出过程, 只需要输出结果的话. 可以用数学方法...

约瑟夫环数学解法
无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达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     --> 0

k+1   --> 1

k+2   --> 2

...

...

k-2   --> n-2

k-1   --> n-1

变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x'=(x+k)%n

如何知道(n-1)个人报数的问题的解？对，只要知道(n-2)个人的解就行了。(n-2)个人的解呢？当然是先求(n-3)的情况 ---- 这显然就是一个倒推问题！好了，思路出来了，下面写递推公式：

令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]

递推公式

f[1]=0;

f[i]=(f[i-1]+m)%i;  (i>1)

有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。因为实际生活中编号总是从1开始，我们输出f[n]+1

由于是逐级递推，不需要保存每个f[i]，程序也是异常简单：

#include <stdio.h>

int main(){

  int n, m, i, s=0;

  printf ("N M = "); scanf("%d%d", &n, &m);

  for (i=2; i<=n; i++) s=(s+m)%i;

  printf ("The winner is %d\n", s+1);

}

这个算法的时间复杂度为O(n)，相对于模拟算法已经有了很大的提高。算n，m等于一百万，一千万的情况不是问题了。可见，适当地运用数学策略，不仅可以让编程变得简单，而且往往会成倍地提高算法执行效率。

int josefus(int n,int m) {
    int l=0,c;
    for(c=1;c<=n;c++)
        l=(l+m-1)%c+1;
    return l;
}

第 3 楼

得分:0

晕了、、、

第 4 楼

得分:0

回复楼主 Love嵌入式

ＬＺ能不嫩把每个操作的伪码写一下
很多看不懂．
非常感谢啦！