循环链表解决约瑟夫 问题

        据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

创建头文件存储函数        circlelist.h

#ifndef _CIRCLELIST_H_H
#define _CIRCLELIST_H_H

typedef void CircleList;


typedef struct _tag_CircleListNode
{
	struct _tag_CircleListNode *next;
	
}CircleListNode;

CircleList *CircleList_Create();

void CircleList_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list,int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* Node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);


#endif // !_CIRCLELIST_H_H

完成函数实现 circlelist.c

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

typedef struct _tag_CircleList
{
	CircleListNode header;
	CircleListNode* slider;//游标
	int length;
}TCircleList;



CircleList *CircleList_Create()
{
	TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
	if (ret == NULL)
	{
		return NULL;
	}
	ret->length = 0;
	ret->header.next = NULL;
	ret->slider = NULL;

	return ret;
}

void CircleList_Destroy(CircleList* list)
{
	if (list==NULL)
	{
		return;
	}
	free(list);
}

void CircleList_Clear(CircleList* list)
{
	TCircleList* sList = (TCircleList*)list;
	if (sList == NULL)
	{
		return;
	}
	sList->length = 0;
	sList->header.next = NULL;
	sList->slider = NULL;
}

int CircleList_Length(CircleList* list)
{
	TCircleList* sList = (TCircleList*)list;
	int ret = -1;
	//if (sList == NULL)	原来 的写法 多了 一个 s
	if (list == NULL)
	{
		return ret;
	}
	ret = sList->length;
	return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
	int ret = 0, i = 0;
	TCircleList* sList = (TCircleList*)list;

	if (list == NULL || node == NULL || pos < 0)
	{
		return -1;
	}
	//if( ret )

	{
		CircleListNode* current = (CircleListNode*)sList;
		for (i = 0; (i < pos) && (current->next != NULL); i++)
		{
			current = current->next;
		}

		//current->next   0号结点的地址
		node->next = current->next;		//1
		current->next = node;	//	2

		//若第一次 插入结点
		if (sList->length == 0)
		{
			sList->slider = node;
		}
		sList->length++;
		//若头插法  current任然指向头部
		//原因是 ，跳 0 步 没有跳走
		if (current == (CircleListNode*)sList)
		{
			//获取最后一个元素、
			CircleListNode *last = CircleList_Get(sList, sList->length - 1);
			last->next = current->next;
		}
	}
	return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos)
{
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	int i = 0;
	if (list == NULL || pos < 0)
	{
		return NULL;
	}
	{
		CircleListNode *current = (CircleListNode*)sList;
		for (i = 0; i < pos; i++)
		{
			current = current->next;
		}
		ret = current->next;
	}
	return ret;
}

CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	int i = 0;

	//if ((sList != NULL) && (pos > 0) && (sList->length < 0));  原来的操作...
	//if ((sList != NULL) && (pos > 0) && (sList->length > 0)) //have a problem
	if ((sList != NULL) && (pos >= 0) && (sList->length > 0)) //have a problem
	{
	// 		CircleListNode* current = (CircleListNode*)(&(sList->header));
	// 		CircleListNode* current = (CircleListNode*)sList;
		CircleListNode* current = (CircleListNode*)sList;//都行 sList 的地址 与sList->header的地址 是重叠 的
		CircleListNode* last = NULL;

		for (i = 0; i < pos; i++)
		{
			current = current->next;
		}
		//若删除第一个元素（头结点）
		if (current == (CircleListNode*)sList)
		{
			last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);
		}
		//求要删除的元素
		ret = current->next;
		current->next = ret->next;

		sList->length--;

		//判断链表是否为空
		if (last != NULL)
		{
			sList->header.next = ret->next;
			last->next = ret->next;		//开始 没有这句....
			//这句的作用是连线
		}

		//若删除的元素为游标所指的元素
		if (sList->slider == ret)
		{
			sList->slider = ret->next;	//游标重新确定
		}

		//若删除元素后，链表长度为 0
		if (sList->length == 0)
		{
			sList->header.next = NULL;
			sList->slider = NULL;
		}
	}
	return ret;
}

//add
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{

	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	int i = 0;
	if (sList != NULL)
	{
		CircleListNode* current = (CircleListNode*)sList;

		//查找node在循环链表中的位置
		for (i = 0; i < sList->length; i++)
		{
			if (current->next == node)
			{
				ret = current->next;
				break;
			}
			current = current->next;
		}
		//如果ret找到  根据i去删除
		if (ret != NULL)
		{
			CircleList_Delete(sList, i);
		}
	}
	return ret;
}

CircleListNode* CircleList_Reset(CircleList* list)
{
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	if (sList != NULL)
	{
		sList->slider = sList->header.next;
		ret = sList->slider;
	}

	return ret;
}

CircleListNode* CircleList_Current(CircleList* list)
{
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	if (sList != NULL)
	{
		ret = sList->slider;
	}
	return ret;
}
//把当前位置返回，并且游标下移
CircleListNode* CircleList_Next(CircleList* list)
{
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	if ((sList != NULL) && (sList->slider != NULL))
	{
		ret = sList->slider;
		sList->slider = ret->next;
	}
	return ret;
}

约瑟夫 问题的调用Josephus.c

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

struct Value
{
	CircleListNode circlenode;
	int v;
};

void main()
{
	int i = 0;
	CircleList* list = CircleList_Create();

	struct Value v1;
	struct Value v2;
	struct Value v3;
	struct Value v4;
	struct Value v5;
	struct Value v6;
	struct Value v7;
	struct Value v8;


	v1.v = 1;
	v2.v = 2;
	v3.v = 3;
	v4.v = 4;
	v5.v = 5;
	v6.v = 6;
	v7.v = 7;
	v8.v = 8;


	CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v5, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v6, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v7, CircleList_Length(list));
	CircleList_Insert(list, (CircleListNode*)&v8, CircleList_Length(list));

	for (i = 0; i <  CircleList_Length(list); i++)	
	{
		//获取游标所指元素，然后游标下移
		struct Value *pv = (struct Value*)CircleList_Get(list, i);

		printf("%d\n", pv->v);
	}
	printf("\n");

	//重置游标
	CircleList_Reset(list);
	while (CircleList_Length(list)>0)
	{
		struct Value* pv = NULL;
		for (i = 1; i < 3; i++)
		{
			CircleList_Next(list);
		}
		pv = (struct Value*)CircleList_Current(list);
		printf("%d\n", pv->v);
		CircleList_DeleteNode(list, (CircleListNode*)pv);
		//不通过位置删除元素 通过 值 删除元素
	}
	

	//重置游标
	CircleList_Destroy(list);

	/*while (CircleList_Length(list) > 0)
	{
	struct Value* pv  = NULL;
	for (i = 1; i < 3;i++)
	{
	CircleList_Next(list);
	}
	}*/

	printf("hello...\n");
	system("pause");
}