约瑟夫问题

#include<malloc.h>
#include<iostream>
using namespace std;


typedef struct node{
int num;
struct node *next;
} SLink;

//先创建
void init(SLink *&L,int *a,int l){

L = (SLink *)malloc(sizeof(SLink));
L->num=a[0];
L->next=L;
SLink *s,*pre=L;

for(int i=1;i<l;i++){
 s = (SLink *)malloc(sizeof(SLink));
 s->next=pre->next;
 pre->next=s;
 s->num=a[i];
 pre=s;
// cout<<a[i];
}


}


//输出

void show(SLink *&L,int n){
 int start=1;
        SLink *pre=L,*p=pre->next;
        while(pre->next!=pre){
                //找到n的前结点n-1
                while(start<n-1){
                        pre=p;
                        p=p->next;
                        start++;//到n-1、跳出循环
                }
                //到这里了 删除p 将pre指向p的后结点
                pre->next=p->next;
                cout<<p->num;
                //free(p);
                pre=p->next;
                free(p);
                p=pre->next;
                start=1; start=1;

        }
        cout<<pre->num;
        free(pre);
}




int main(){
int a[5]={1,2,3,4,5};
SLink *L;
init(L,a,5);
show(L,3);

return 0;
}
 

void show(SLink *&L,int n){
    //注意问题这个算法只能从第二个元素开始出队 如果为1则结果错误
        int start=1;//设置当前指向要出对的结点前结点为L时start=1 当指向第n个结点的前结点时 start=n-1
        SLink *pre=L,*p=pre->next;
        //当结点没有指向自身时循环
        while(pre->next!=pre){
                //找到n的前结点n-1
                while(start<n-1){
                        pre=p;
                        p=p->next;
                        start++;//到n-1、跳出循环
                }
                //到这里了指向n的前结点
                pre->next=p->next;//将前结点的指针指向要删除的结点的后结点
                cout<<p->num; //输出要删除的结点的内容
                //free(p);
                pre=p->next;//pre指向将要删除的结点的后继结点
                free(p);//删除结点
                p=pre->next;//要删除的结点指向pre的后继结点
                start=1;//还是相当于从第一个开始

        }
        //释放最后一个剩下来的结点
        cout<<pre->num;
        free(pre);
}

12345
4512 3
245 1
24 5
4 2
4

12345
3451  2
513 4
35 1
3 5
3

12345
1234 5
234 1
42 3
2 4
2

从第一个结点开始出队我本人也想不到啥好的方法，有想法的可以分享一下谢谢！