数据结构：单、双链表解决约瑟夫问题

 单向循环链表 解决约瑟夫问题约瑟夫问题为：设编号为1，2，……n得n个人围坐一圈，约定编号为k（k大于等于1并且小于等于n）的人从1开始报数，数到m的那个人出列。它的下一位继续从1开始报数，数到m的人出列，依次类推，最后剩下一个为猴王。直接上图展示，初始化状态：假设n=6，总共有6个人，k=1,从第一个人开始报数，m=5,每次数五个。 

 第一次报数：从一号开始，数五个数，1-2-3-4-5，数完五个数，五号被杀死，第一次报数后，剩余人数如下。

 第二次报数：从被杀死的五号的下一位开始报数，也就是六号，数五个数，6-1-2-3-4，数数完毕，四号被杀死，第二次报数后，剩余人数如下。

 第三次报数：从被杀死的四号的下一位开始报数，同样是六号，数五个数，6-1-2-3-6，数数完毕，六号被杀死，第三次报数后，剩余人数如下。

 第四次报数：从被杀死的六号的下一位开始报数，也就是一号，数五个数，1-2-3-1-2，数数完毕，二号被杀死，第四次报数后，剩余人数如下。

 第五次报数：从被杀死的二号的下一位开始报数，也就是三号，数五个数，3-1-3-1-3，数数完毕，三号被杀死，只剩下一号

 

---

单链表解决具体代码实现： 

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

typedef struct node_t
{
    int data;
    struct node_t *next;
 }link_node_t,*link_list_t;
 
 int main()
 {
     int i;
     link_list_t pdel=NULL;//指向被删除节点
    link_list_t pnew=NULL;//指向新创建节点
    link_list_t ptail=NULL;//指向当前链表尾
    link_list_t h=NULL;//头指针
    
    int all_num;//猴子总数
    int start_num;//从几号猴子开始
    int kill_num;//数到几杀死
    printf("总数 从谁开始 数到几\n");
    scanf("%d%d%d",&all_num,&start_num,&kill_num);
    
    //1.创建单向循环链表
    //（1）创建单向链表    
    h=(link_list_t) malloc(sizeof(link_node_t));
    if(h==NULL){
        printf("error\n");
        return -1;
    }
    h->data=1;//第一个节点赋值 
    h->next=NULL;
    
    //尾指针指向当前第一个节点
    ptail=h;
    
    for(i=2;i<=all_num;i++){
        //创建新节点 
        pnew=(link_list_t) malloc(sizeof(link_node_t));
        if(pnew==NULL){
            printf("error\n");
            return -1;
        }
        //给新结点赋值
        pnew->data=i;
        pnew->next=NULL;
        //新节点链接到表尾
        ptail->next=pnew;
        ptail=pnew;
    }
    //(2)把头指针保存到链表尾形成单向循环链表
    ptail->next=h; 
    //test
    /*while(1)
    {
        printf("%d\n",h->data);
        h=h->next;
        sleep(1);
    }*/
    //移动到开始猴子处
        for(i=0;i<start_num-1;i++)
    {
        h=h->next;
    }
    //循环杀死猴子
        while(h->next!=h){
        for(i=0;i<kill_num-1-1;i++){//找猴子
                h=h->next;
        }
     // printf("now kill id=%d\n", h->next->data);
        pdel=h->next;
        h->next=pdel->next;
        printf("kill is %d\n",pdel->data);
        free(pdel);
        pdel=NULL;
        // 继续把后面连起来 
        h=h->next;
        printf("new start id=%d\n", h->data);

    }
        printf("king id ======== %d\n", h->data);        
     return 0;
 }

双链表解决具体代码实现：  

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

typedef int datatype;
typedef struct node_t
{
    datatype data;
    struct node_t *prior;
    struct node_t *next;
 } link_node_t,*link_list_t;
 
typedef struct doublinklist
{
    link_list_t head;
    link_list_t tail;
}double_node_t,*double_list_t;

int main()
{
    int i;
    int all_num=8;
    int start_num=3;
    int kill_num=3;
    link_list_t h=NULL;
    link_list_t pdel=NULL;
    scanf("%d%d%d",&all_num,&start_num,&kill_num);
    
    //1.创建双向循环链表
     double_list_t p=(double_list_t)malloc(sizeof(double_node_t));
     if(p==NULL){
         printf("error\n");
         return -1;
     }
    p->head=p->tail=(link_list_t)malloc(sizeof(link_node_t));
    if(p->tail==NULL){
        printf("error\n");
         return -1;
    }
    p->head->data=1;
    p->head->prior=NULL;
    p->head->next=NULL;
    //创建新节点链接到表尾
    for(i=2;i<=all_num;i++){
        link_list_t pnew=(link_list_t)malloc(sizeof(link_node_t));
        if(pnew==NULL){
            printf("error\n");
             return -1;
        }
        pnew->data=i;
        pnew->prior=NULL;
        pnew->next=NULL;
        //(1)将新节点链接到链表尾
        p->tail->next=pnew;
        pnew->prior=p->tail; 
        //(2)尾指针向后移动
        p->tail=pnew; 
    } 
    //(3)形成双向循环链表
    p->tail->next=p->head;
    p->head->prior=p->tail; 
    //调试数据 
    #if 0
    while(1){
        printf("%d\n",p->head->data);
        p->head=p->head->next;
        sleep(1);
    }
    #endif
    //2.循环杀死猴子
    h=p->head; 
    //(1)移动到开始猴子 
    for(i=0;i<start_num-1;i++){
        h=h->next;
    } 
    while(h->next!=h){//只剩一个节点退出 
        //(2)先将h移动到将要被杀死的猴子处
        for(i=0;i<kill_num-1;i++){
            h=h->next;
        } 
        //h已经指向要杀死猴子处，杀死
        h->prior->next=h->next;
        h->next->prior=h->prior; 
        pdel=h;
        printf("kill is %d\n",pdel->data);
        h=h->next;//向后移动
        free(pdel);
        pdel=NULL; 
    }
    printf("king is %d\n",h->data);
    return 0;
}