约瑟夫环

约瑟夫环的数组实现

/*约瑟夫环的实现*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define SIZE 10
#define STEP 5

void initArray(int arr[SIZE]);
void joseph_1();
void joseph_2();

int main()
{
    joseph_2();
    return 0;
}

void initArray(int arr[SIZE])
{
    int i;
    for(i = 0; i < SIZE; i++)
        arr[i] = i+1;
}

/*建立一个SIZE个元素的循环数组，从数组头开始遍历并计数，
 *如果计数i == STEP则剔除元素，继续循环，
 *当当前元素与下一个元素相同时退出循环。 
 * */
void joseph_1()
{
    int count;//计数
    int next;//下一个数数元素的下标
    int move;//删除一个元素后，其后的元素前移的工作指针
    int currentNum;//记录剩下的元素个数
    int arr[SIZE];

    next = 0;
    currentNum = SIZE;
    initArray(arr);

    while(currentNum != 1)
    {
        count = 1;
        while(count != STEP)
        {
            //到达最右端
            if(next + 1 == currentNum)
                next = 0;
            else
                next++;
            count++;
        }
        //打印出队的元素
        printf("%2d->",arr[next]);
        //next后的元素前移
        for(move = next + 1; move < currentNum; move++)
            arr[move-1] = arr[move];
        //如果剔除的所最有端元素，下一个数数的元素应该所第一个，否则不变
        if(next + 1 == currentNum)
            next = 0;
        currentNum--;
    }
    printf("
The winner is :%d
",arr[0]);    
}
//将数到的元素置零，只需找到最后一个非零元素即可
void joseph_2()
{
    int i;//工作指针
    int count;//计数
    int currentNum;//记录剩下的元素个数
    int next;
    int arr[SIZE];

    count = 0;
    next = 0;
    currentNum = SIZE;
    initArray(arr);

    while(currentNum != 1)
    {
        if(arr[next] != 0)
        {
            count++;
            if(count == STEP)
            {
                printf("%2d->",arr[next]);
                arr[next] = 0;
                count = 0;
                currentNum--;
            }
            else
                next = (next + 1) % SIZE;
        }
        else
            next = (next + 1) % SIZE;
    }
    //找到最后一个非零元素
    for(i = 0; i < SIZE; i++)
        if(arr[i] != 0)
            printf("
The winner is:%d
",arr[i]);
}

 约瑟夫环的链表实现：

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

typedef struct Node
{
    int data;
    struct Node* next;
}NODE;

//初始化链表
NODE *init(int n);
//从K个人开始计数，数到M的人退出圈
void link(NODE *head, int k, int m);

int main()
{
    NODE *head = init(10);
    link(head,1,5);
    return 0;
}

//初始化链表
NODE *init(int n)
{
    int i;
    NODE *head,*pcur,*pnew;

    //创建第一个结点
    head = (NODE*)malloc(sizeof(NODE));
    head->data = 1;
    pcur = head;

    //创建后面的结点
    for(i = 2; i <= n; i++)
    {
        pnew = (NODE*)malloc(sizeof(NODE));
        pnew->data = i;

        pcur->next = pnew;
        pcur = pnew;
    }
    //形成环
    pcur->next = head;
    return head;
}


//从K个人开始计数，数到M的人退出圈
void link(NODE *head, int k, int m)
{
    NODE *pcur, *ppre;
    int i;

    pcur = head;
    //将指针移动到第K的人处
    while(pcur->data < k)
        pcur = pcur->next;

    while(pcur->next != pcur)
    {
        for(i = 1; i < m; i++)
        {
            ppre = pcur;
            pcur = pcur->next;
        }
        //打印出队元素
        printf("->%2d",pcur->data);
        //出队
        ppre->next = pcur->next;
        free(pcur);
        pcur = ppre->next;
    }
    printf("->%2d",pcur->data);
    printf("
The winner is %d
",pcur->data);
    //释放最后一个结点
    free(pcur);
}