基本算法——约瑟夫环问题

关于约瑟夫环问题，我们可以从两种思路去实现，一种是用数组，另一种是采用链表。

用数组方法实现代码:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M 8
int find(int *arr, int len);
int main(int argc, char* argv[])
{
    int size = atoi(argv[1]);
    int* arr = (int*)calloc(size, 4);
    int index ;
    for(index = 0; index < size ; index ++)
    {
        arr[index] = index + 1 ;
    }
    printf("
winner: %d 
", find(arr, size));
    return 0 ;
}
int find(int *arr, int len)
{
    int index , step ;
    int size = len ;
    index = 0 ;
    step = 0 ;
    while(len > 1)
    {
        if(arr[index] != 0)
        {
            ++step ;
            if(step == M)
            {
                printf("%3d", index + 1);
                arr[index] = 0 ;
                step = 0 ;
                len -- ;
            }
        }
        index = (index + 1) % size ;
    }
    for(index = 0 ; index < size ; index ++)
    {
        if(arr[index] != 0)
        {
            return arr[index] ;
        }
    }
}

该方法就是采用一个计数，同时还要有一个变量来跟随数组下标，每当计数与我们规定的退出值相等时，将数组中当前下标的值置为0，无形中增加了许多判断。

用链表方法实现代码:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M 8
typedef struct tag
{
    int num;
    struct tag *next;
}Node, *pNode;
void link_create(pNode *head, int size);
void link_del(pNode *head, int a);
int find(pNode *head, int size);
int main(int argc, char* argv[])
{
    int size = atoi(argv[1]);
    pNode head;
    link_create(&head, size);
    printf("
winner: %d 
", find(&head, size));
    return 0 ;
}

int find(pNode *head, int size)
{
    pNode  pcur = *head, ppre = NULL;
    int step = 1;
    while(size > 1)
    {
        if(step == M)
        {
            step = 1;
            printf("%3d", pcur->num);
            pNode p = pcur;
            ppre->next = pcur->next;
            free(p);
            pcur = ppre->next;
            -- size;
        }
        else
        {
            ++ step;
            ppre = pcur;
            pcur = pcur->next;
        }
    }
    return pcur->num;
}

void link_create(pNode *head, int size)
{
    pNode p;
    *head = NULL;
    while(size > 0)
    {
        p = (pNode)calloc(1, sizeof(Node));
        p->num = size;
        p->next = *head;
        *head = p;
        -- size;
    }
    p = *head;
    while(p->next)
    {
        p = p->next;
    }
    p->next = *head;
}

在这里，我们创建一个链表环，这样，每次计数增加时，链表会指向下一个，无需我们再去跟踪该位置是哪个，我们只需判断计数是否为我们规定的退出值，让链表一直循环即可，当链表中只剩下一个元素是，该值就是我们的胜利者。

在该链表中，我们采用了一种创建环的方法，即将链表的尾指针指向头指针，这里需要注意一下。