单向循环链表—解决约瑟夫问题

最新推荐文章于 2022-07-22 08:50:23 发布

孔_

最新推荐文章于 2022-07-22 08:50:23 发布

阅读量2k

点赞数

分类专栏： C/C++提高文章标签：数据结构

本文链接：https://blog.youkuaiyun.com/qq_42368382/article/details/123765014

版权

C/C++提高专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一个使用循环链表实现的经典约瑟夫问题解决方案。通过自定义的数据结构和链表操作，实现了约瑟夫问题的模拟，并最终找到了存活者。文章详细解释了循环链表的创建、节点插入、删除等核心操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、题目描述：

二、解决方案：

一、题目描述：

二、解决方案：

CircleLinklist.h

//author:kdf
//title:循环链表
//time:2022/3/26

#ifndef CIRCLELINKLIST_H_INCLUDED
#define CIRCLELINKLIST_H_INCLUDED

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



//链表小节点
typedef struct CIRCLELINKNODE
{
    struct CIRCLELINKNODE* next;

}CircleLinkNode;

//链表结构体
typedef struct CIRCLELINKLIST
{
    CircleLinkNode head;
    int size;


}CircleLinkList;

//宏定义
#define CIRCLELINKLIST_TRUE 1
#define CIRCLELINKLIST_FALSE 0

//比较回调
typedef int(*COMPARENODE)(CircleLinkNode*,CircleLinkNode*);
//打印回调
typedef void(*PRINTNODE)(CircleLinkNode*);

//API 函数
//初始化函数
CircleLinkList* Init_CircleLinkList();
//插入函数
void Insert_CircleLinkList(CircleLinkList* clist,int pos,CircleLinkNode* data);
//获取第一个元素
CircleLinkNode* Front_CircleLinkList(CircleLinkList* clist);
//根据位置进行删除
void RemoveByPos_CircleLinkList(CircleLinkList* clist,int pos);
//根据值删除
void RemoveByValue_CircleLinkList(CircleLinkList* clist,CircleLinkNode* data,COMPARENODE compare);
//获得链表长度
int Size_CircleLinkList(CircleLinkList* clist);
//判断是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist);
//查找
int Find_CircleLinkList(CircleLinkList* clist,CircleLinkNode* data,COMPARENODE compare);
//打印节点
void Print_CircleLinkList(CircleLinkList* clist,PRINTNODE print);
void Free_CircleLinkList(CircleLinkList* clist);

#endif // CIRCLELINKLIST_H_INCLUDED

CircleLinklist.cpp

//author:kdf
//title:循环链表
//time:2022/3/26
#include "CircleLinklist.h"

//初始化函数
CircleLinkList* Init_CircleLinkList()
{
    CircleLinkList* clist=(CircleLinkList*)malloc(sizeof(CircleLinkList));
    clist->head.next=&(clist->head);
    clist->size=0;
    return clist;
}
//插入函数
void Insert_CircleLinkList(CircleLinkList* clist,int pos,CircleLinkNode* data)
{

    if(clist==NULL)
    {
        return;
    }
    if(data==NULL)
    {
        return;
    }
    //友好判断
    if(pos<0 || pos>clist->size)
    {
        pos=clist->size;
    }
    //根据位置查找节点
    //辅助指针变量
    CircleLinkNode* pCurrent=&(clist->head);
    for(int i=0;i<pos;i++)
    {
        pCurrent=pCurrent->next;
    }

    //新数据入链表
    data->next=pCurrent->next;
    pCurrent->next=data;

    clist->size++;
}
//获取第一个元素
CircleLinkNode* Front_CircleLinkList(CircleLinkList* clist)
{
    return clist->head.next;

}
//根据位置进行删除
void RemoveByPos_CircleLinkList(CircleLinkList* clist,int pos)
{

    if(clist==NULL)
    {
        return;
    }
    if(pos<0 || pos>=clist->size)
    {
        return;
    }
    //辅助指针变量
    CircleLinkNode* pCurrent=&(clist->head);
    for(int i=0;i<pos;i++)
    {
        pCurrent=pCurrent->next;
    }

    //缓存当前结点的下一结点
    CircleLinkNode* pNext=pCurrent->next;
    pCurrent->next=pNext->next;

    clist->size--;

}
//根据值删除
void RemoveByValue_CircleLinkList(CircleLinkList* clist,CircleLinkNode* data,COMPARENODE compare)
{
     if(clist==NULL)
    {
        return;
    }
    if(data==NULL)
    {
        return;
    }
    //循环链表
     CircleLinkNode* pPrev=&(clist->head);
     CircleLinkNode* pCurrent=pPrev->next;
     for(int i=0;i<clist->size;i++)
     {
         if(compare(pCurrent,data)==CIRCLELINKLIST_TRUE)
         {
             pPrev->next=pCurrent->next;
             clist->size--;
             break;

         }
         pPrev=pCurrent;
         pCurrent=pPrev->next;
     }




}
//获得链表长度
int Size_CircleLinkList(CircleLinkList* clist)
{
    return clist->size;
}
//判断是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist)
{
    if(clist->size==0)
    {
        return CIRCLELINKLIST_TRUE;
    }
    else
    {
        return CIRCLELINKLIST_FALSE;
    }
}
//查找
int Find_CircleLinkList(CircleLinkList* clist,CircleLinkNode* data,COMPARENODE compare)
{


     if(clist==NULL)
    {
        return -1;
    }
    if(data==NULL)
    {
        return -1;
    }
    //辅助指针变量
    CircleLinkNode* pCurrent=clist->head.next;
    int flag=-1;
    for(int i=0;i<clist->size;i++)
    {
        if(compare(pCurrent,data)==CIRCLELINKLIST_TRUE)
        {
           flag=i;
            break;
        }
        pCurrent=pCurrent->next;
    }

   return flag;
}
//打印节点
void Print_CircleLinkList(CircleLinkList* clist,PRINTNODE print)
{
      if(clist==NULL)
    {
        return ;
    }

    CircleLinkNode* pCurrent=clist->head.next;
    for(int i=0;i<clist->size;i++)
    {
        if(pCurrent==&(clist->head))
        {
             pCurrent=pCurrent->next;
             printf("----------------------\n");
        }
        print(pCurrent);
        pCurrent=pCurrent->next;
    }
}
void Free_CircleLinkList(CircleLinkList* clist)
{
     if(clist==NULL)
    {
        return ;
    }
    free(clist);

}

main.cpp

//title:约瑟夫问题

#include <iostream>
#include "CircleLinklist.h"
using namespace std;
#define M 8
#define N 3

typedef struct MYNUM
{
    CircleLinkNode node;
    int val;
}MyNum;



void MyPrint(CircleLinkNode* data)
{
    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;
}

int main()
{
    //创建循环链表
    CircleLinkList* clist=Init_CircleLinkList();

    //插入数据
    MyNum num[M];
    for(int i=0;i<8;i++)
    {
        num[i].val=i+1;
        Insert_CircleLinkList(clist,i,(CircleLinkNode*)&num[i]);
    }

    //打印
    Print_CircleLinkList(clist,MyPrint);
    printf("\n");

    int index=1;
    CircleLinkNode* pCurrent=clist->head.next;
    while(Size_CircleLinkList(clist)>1)
    {
        if(index==N)
        {
            MyNum* TemNum=(MyNum*)pCurrent;
            printf("%d ",TemNum->val);

            //缓存待删除结点的下一结点
            CircleLinkNode* pNext=pCurrent->next;
            //删除节点
            RemoveByValue_CircleLinkList(clist,pCurrent,MyCompare);
            pCurrent=pNext;
            //当循环一圈指向头结点时，指向下一结点
            if(pCurrent==&(clist->head))
            {
                pCurrent=pCurrent->next;
            }
            index=1;
            //printf("(%d)\n",Size_CircleLinkList(clist));
        }

            pCurrent=pCurrent->next;
            if(pCurrent==&(clist->head))
            {
                pCurrent=pCurrent->next;
            }
            index++;



    }



    if(Size_CircleLinkList(clist)==1)
    {
         MyNum* TemNum=(MyNum*)Front_CircleLinkList(clist);
         printf("%d ",TemNum->val);
    }
    else
    {
        printf("出错了!\n");
    }

     printf("\n");

    //释放
    Free_CircleLinkList(clist);

   // cout << "Hello world!" << endl;
    return 0;
}