单向循环链表（约瑟夫问题）

1.对于单向循环链表，其实跟普通的链表实现差不太多，单向循环链表只是将尾节点指向了头节点。

2.本链表的实现依然采用企业链表的实现方式

单向循环链表的定义：

//.h头文件

#ifndef CIRCLELINKLIST_H
#define CIRCLELINKLIST_H

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

#define CIRCLELINKLIST_TRUE 1
#define CIRCLELINKLIST_FALSE 0

//创建链表节点结构体
typedef struct CIRCLELINKNODE
{
    struct CIRCLELINKNode* next;
}CircleLinkNode;

//创建链表结构体
typedef struct CIRCLELINKLIST
{
    CircleLinkNode head;
    int size;
}CircleLinkList;

//定义函数指针
typedef int(*COMPARENODE)(CircleLinkNode*,CircleLinkNode*);
typedef void(*PRINTNODE)(CircleLinkNode*);

//链表初始化
CircleLinkList* Init_CircleLinkList();

//插入
void Insert_CircleLinkList(CircleLinkList* list,CircleLinkNode* data);

//根据值删除
void RemoveByValue_CircleLinkList(CircleLinkList*list,CircleLinkNode* data,COMPARENODE compare);

//根据位置删除
void RemoveByPos_CircleLinkList(CircleLinkList* list,int pos);

//查找
int Find_CircleLinkList(CircleLinkList* list,CircleLinkNode* data,COMPARENODE compare);

//打印
void Print_CircleLinkList(CircleLinkList*list,PRINTNODE print);

//获得链表长度
int Size_CircleLinkList(CircleLinkList* clist);

//判断是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist);

//获取第一个节点
CircleLinkNode* Front_CircleLinkLis(CircleLinkList* clist);

//释放内存
void FreeSpace_CircleLinkList(CircleLinkList* list);

#endif

//.c 文件

#include"CircleLinkList.h"

#define M 8
#define N 3

//实现函数指针，约瑟夫问题
typedef struct MYNUM
{
    CircleLinkNode node;
    int val;
}MyNum;

void MyPrint(CircleLinkNode* data)
{
    if(data == NULL) return;
    MyNum* num = (MyNum*)data;
    
    printf("%d ",num->val);
}

int MyCompare(CircleLinkNode* data1,CircleLinkNode* data2)
{
    MyNum* num1 = (MyNum*)data1;
    MyNum* num2 = (MyNum*)data2;

    if(num1->val == num2->val)
        return CIRCLELINKLIST_TRUE;
    return  CIRCLELINKLIST_FALSE;
}


//链表初始化
CircleLinkList* Init_CircleLinkList()
{
    CircleLinkList* list = (CircleLinkList)malloc(sizeof(CircleLinkList));
    list->head.next = list->head;    //将尾指向头，形成一个循环
    list->size = 0;
    
    retrun list;
}

//插入
void Insert_CircleLinkList(CircleLinkList* list,int pos,CircleLinkNode* data)
{
    //首先进行条件判断
    if(list == NULL) return;
    if(data == NULL) return;

    if(pos < 0 || pos > list->size)
        pos = list->size;
    
    //移动指针，设置辅助指针
    CircleLinkNode* pCurrent = &(list->head);
    for(int i = 0; i < pos; i++)
    {
        pCurrent = pCurrent->next;
    }

    data->next = pCurrent->next;
    pCurrent->next = data;

    list->size++;
}

//根据值删除
void RemoveByValue_CircleLinkList(CircleLinkList*list,CircleLinkNode* data,COMPARENODE compare)
{
    if(list == NULL) return;
    if(data == NULL) return;

    CircleLinkNode* pCurrent = list->head.next;
    for(int i = 0; i < list->size - 1; i++)
    {
        if(compare(pCurrent,data) == CIRCLELINKLIST_TRUE)        //找到
        {
            pCurrent->next = pCurrent->next->next;
            list->size--;
            break;
        }
        pCurrent = pCurrent->next;
    }

}

//根据位置删除
void RemoveByPos_CircleLinkList(CircleLinkList* list,int pos)
{
    //首先进行条件判断
    if(list == NULL) return;

    if(pos < 0 || pos > list->size) return;
    
    //移动指针，设置辅助指针
    CircleLinkNode* pCurrent = &(list->head);
    for(int i = 0; i < pos; i++)
    {
        pCurrent = pCurrent->next;
    }

    pCurrent->next = pCurrent->next->next;

    list->size--;
}

//查找
int Find_CircleLinkList(CircleLinkList* list,CircleLinkNode* data,COMPARENODE compare)
{
    if(list == NULL)    return -1;
    if(data == NULL)    return -1;
    
    //移动指针，设置辅助指针
    int flag = 0;
    CircleLinkNode* pCurrent = &(list->head);
    for(int i = 0; i < list->size ; i++)
    {
        pCurrent = pCurrent->next;
        //查找到需要的值
        if(compare(pCurrent,data) == CIRCLELINKLIST_TRUE)
        {
            flag = i;
            break;
        }
    }
    return flag;
}

//打印
void Print_CircleLinkList(CircleLinkList*list,PRINTNODE print)
{
    if(list == NULL)    return;
    
    CircleLinkNode* pCurrent = list->head.next; 
    for(int i = 0; i < list->size; i++)
    {
        if(pCurrent == &(list->head))
        {
            return;
        }
        pCurrent = pCurrent->next;
        print(pCurrent);
    }
}

//获得链表长度
int Size_CircleLinkList(CircleLinkList* list)
{
    return list->size;
}

//判断是否为空
int IsEmpty_CircleLinkList(CircleLinkList* list)
{
    if(list == NULL)    return CIRCLELINKLIST_TRUE;
    return CIRCLELINKLIST_FALSE;
}

//获取第一个节点
CircleLinkNode* Front_CircleLinkLis(CircleLinkList* list)
{
    return list->head.next;
}

//释放内存
void FreeSpace_CircleLinkList(CircleLinkList* list)
{
    if(list == NULL)    return;
    free(list);
}


int main()
{

    //实现约瑟夫问题
    
    //创建循环链表
    CircleLinkList* list = Init_CircleLinkList();

    //进行数据定义
    MyNun num[M];
    for(int i = 0;i < M;i++)
    {
        num[i].val = i+1;
        Insert_CircleLinkList(list,i,(CircleLinkNode*)&num[i]);
    }

    //打印
    Print_CircleLinkList(list,MyPrint);

    int index = 1;
    //辅助指针
    CircleLinkNode* pCurrent = list->head.next;
    while(Size_CircleLinkList(list) > 1)
    {
        if(index == N)
        {
            MyNum* temNum = (MyNum*)pCurrent;
            printf("%d ",temNum->val);

            //缓存待删除节点的下一个节点
            CircleLinkNode* pNext = pCurrent->next;
            
        }

        pCurrent = pCurrent->next;
        index++;
    }

    //释放链表内存
    Free_CircleLinkList(clist);

    return 0;
}