C语言头结点的循环企业链表实现约瑟夫问题

循环企业链表的声明 

#pragma once

typedef struct LINKNODE
{
	struct LINKNODE *next;
}LinkNode;

typedef struct LINKLIST
{
	LinkNode head;
	int size;
}LinkList;

typedef void(*PRINTNODE)(LinkNode*);                                                // 打印函数指针
typedef int(*COMPARENNODE)(LinkNode*, LinkNode*);                                   // 比较函数指针



LinkList* Init_LinkList();                                                          // 初始化链表
void Insert_LinkList(LinkList* list, int pos, LinkNode* data);                      // 插入
LinkNode* Front_LinkList(LinkList* list);                                           // 获得第一个元素
void Remove_LinkList(LinkList* list, int pos);                                      // 根据位置删除
void RemoveByValue_LinkList(LinkList* list, LinkNode* data, COMPARENNODE compare);  // 根据值删除
int Find_LinkList(LinkList* list, LinkNode* data,COMPARENNODE compare);             // 查找
int Size_LinkList(LinkList* list);                                                  // 返回链表的长度
void Print_LinkList(LinkList* list, PRINTNODE print);                               // 打印
void FreeSpace_LinkList(LinkList* list);                                            // 释放链表内存
int IsEmpty_LinkList(LinkList* list);                                               // 判断链表是否为空

循环企业链表的函数实现

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

LinkList* Init_LinkList()
{
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	list->head.next = NULL;
	list->head.next = &(list->head);                            // 循环链表
	list->size = 0;
	return list;
}


void Insert_LinkList(LinkList* list, int pos, LinkNode* data)   // 插入
{
	if (list == NULL)
		return;

	if (data == NULL)
		return;

	if (pos<0 || pos>list->size)
	{
		pos = list->size;                                        // 如果插入位置不合法，插入到尾部
	}

	LinkNode* pCurrent = &(list->head);
	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	data->next = pCurrent->next;
	pCurrent->next = data;               // 插入到链表

	list->size++;
}

LinkNode* Front_LinkList(LinkList* list)
{
	return list->head.next;
}



void Remove_LinkList(LinkList* list, int pos)
{
	if (list == NULL)
		return;
	

	if (pos < 0 || pos >= list->size)
		return;
	
		

	LinkNode *pCurrent = &(list->head);
	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}
	
	pCurrent->next = pCurrent->next->next;     // 删除结点

	list->size--;
}

void RemoveByValue_LinkList(LinkList* list, LinkNode* data, COMPARENNODE compare)
{
	if (list == NULL)
		return;

	if (data == NULL)
		return;

	LinkNode* pPrev = &(list->head);
	LinkNode* pCurrent = list->head.next;
	for (int i = 0; i < list->size; i++)
	{
		if (compare(pCurrent, data) == 0)
		{
			pPrev->next = pCurrent->next;
			break;
		}
		pPrev = pCurrent;
		pCurrent = pCurrent->next;
	}
	list->size--;
}

int IsEmpty_LinkList(LinkList* list)
{
	if (list->size == 0)
		return 1;
	else
		return 0;
}




void FreeSpace_LinkList(LinkList* list)
{
	if (list == NULL)
	{
		return;
	}
	free(list);
}

int Find_LinkList(LinkList* list, LinkNode* data, COMPARENNODE compare)
{
	if (list == NULL)
		return -1;

	if (data == NULL)
		return -1;

	int index = 0;
	int flag = -1;
	LinkNode* pCurrent = list->head.next;
	for(int i=0;i<list->size;i++)
	{
		if (compare(pCurrent, data) == 0)
		{
			flag = index;
			break;
		}
		pCurrent = pCurrent->next;
		index++;
	}
	return flag;
}

int Size_LinkList(LinkList* list)
{
	if (list == NULL)
		return -1;

	return list->size;
}

void Print_LinkList(LinkList* list, PRINTNODE print)
{
	if (list == NULL)
		return;

	LinkNode* pCurrent = list->head.next;
	for (int i = 0; i < list->size; i++)
	{
		if (pCurrent == &(list->head))
		{
			pCurrent = pCurrent->next;
			//printf("---------------------\n");
		}
			
		print(pCurrent);
		pCurrent = pCurrent->next;
	}
	
}

约瑟夫问题测试函数

#define  _CRT_SECURE_NO_WARNINGS
#include "List.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


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


#define M 8         // 约瑟夫游戏人数
#define N 3         // 数M个人出圈

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

int MyCompare(LinkNode* node1, LinkNode* node2)
{
	MyNum* p1 = (MyNum*)node1;                // 类型强转
	MyNum* p2 = (MyNum*)node2;

	if (p1->val == p2->val)
		return 0;

	return -1;
}

int main()
{
	LinkList *list = Init_LinkList();
	MyNum num[M];
	for (int i = 0; i < 8; i++)
	{
		num[i].val = i + 1;
		Insert_LinkList(list, i, (LinkNode*)&num[i]);
	}
	Print_LinkList(list,MyPrint);
	printf("\n");
	int index = 1;
	LinkNode* pCurrent = list->head.next;


	while (Size_LinkList(list) > 1)
	{
		if (index == N)
		{
			MyNum* temNum = (MyNum*)pCurrent;
			printf("%d ", temNum->val);             // 输出退出圈的人

			LinkNode* pNext = pCurrent->next;       // 缓存待删除结点的下一个结点

			RemoveByValue_LinkList(list, pCurrent, MyCompare);

			pCurrent = pNext;

			if (pCurrent == &(list->head))
			{
				pCurrent = pCurrent->next;           // 遇到头节点跳出
			}

			index = 1;
			
		}
		index++;
		pCurrent = pCurrent->next;
		if (pCurrent == &(list->head))
		{
			pCurrent = pCurrent->next;           // 遇到头节点跳出
		}
		
	}
	if (Size_LinkList(list) == 1)
	{
		MyNum* tempNum = (MyNum*)Front_LinkList(list);
		printf("%d\n", tempNum->val);            //  输出幸存者
	}
	else
	{
		printf("Wrong\n");
	}

	FreeSpace_LinkList(list);
	system("pause");
}