顺序表解决约瑟夫环问题

Seq.h

#ifndef _SEQ_H_
#define _SEQ_H_

#define INIT_SIZE 10
#define ADD_SIZE   5

typedef enum {TRUE, FALSE, ERROR} BOOL;

typedef int Data;
typedef struct _Seq
{
	Data *data;				//存放顺序表数据
	int maxSize;			//顺序表最大存储空间
	int size;				//顺序表当前存储空间
}Seq;


/*
	函数名:*Creat_Seq()
	函数功能:创建顺序表
	返回值:创建的顺序表的地址
*/
Seq *Creat_Seq();


/*
	函数名:Again_Malloc(Seq *s)
	函数功能:扩展顺序表的空间
	s:要扩展空间的顺序表
	返回值:扩展成功TRUE,扩展失败FALSE,其他情况ERROR
*/
BOOL Again_Malloc(Seq *s);


/*
	函数名:Insert_Last(Seq *s, Data data)
	函数功能:从尾部插入数据
	s:要插入数据的顺序表
	data:要插入的数据
	返回值:插入成功TRUE,插入失败FALSE,其他情况ERROR
*/	
BOOL Insert_Last(Seq *s, Data data);


/*
	函数名:Insert_Head(Seq *s, Data data)
	函数功能:从头部插入数据
	s:要插入数据的顺序表
	data:要插入的数据
	返回值:插入成功TRUE,插入失败FALSE,其他情况ERROR
*/	
BOOL Insert_Head(Seq *s, Data data);


/*
	函数名:Insert_Pos(Seq *s, int pos, Data data)
	函数功能:从指定位置插入数据
	s:要插入数据的顺序表
	pos:插入数据的位置
	data:要插入的数据
	返回值:插入成功TRUE,插入失败FALSE,其他情况ERROR
*/	
BOOL Insert_Pos(Seq *s, int pos, Data data);


/*
	函数名:Delete_Pos(Seq *s, int pos)
	函数功能:删除指定位置的数据
	s:要删除数据的顺序表
	pos:删除数据的位置
	返回值:删除成功TRUE,删除失败FALSE,其他情况ERROR
*/	
BOOL Delete_Pos(Seq *s, int pos);


/*
	函数名:Delete_Data
	函数功能:删除某个特定的数据
	s    ：要删除的顺序表
	data : 要删除的数据
	返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
*/
BOOL Delete_Data(Seq* s, Data data);


/*
	函数名:Find_Data
	函数功能:查找某个特定的数据
	s    ：要查找的顺序表
	data : 要查找的数据
	index: 要查找的数据的下标
	返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
*/
BOOL Find_Data(Seq* s, Data data, int *pIndex);


/*
	函数名:Modify_Data
	函数功能:修改指定位置的数据
	s:要修改数据的顺序表
	index:修改数据的下标
	data:要修改的值
	返回值:删除成功TRUE,删除失败FALSE,其他情况ERROR
*/	
BOOL Modify_Data(Seq* s, int index, Data data);


/*
	函数名:Merge_Seq
	函数功能:按顺序合并两个排好序的顺序表
	s1:要合并的顺序表1
	s2:要合并的顺序表1
	返回值:合并后的顺序表3的地址
*/
Seq *Merge_Seq(Seq *s1, Seq *s2);


/*
	函数名:Display_Seq(Seq *s)
	函数功能:显示顺序表中所有数据
	s:要显示的顺序表
*/
void Display_Seq(Seq *s);


/*
	函数名:Destroy_Seq(Seq *s)
	s:要销毁的顺序表
	函数功能:销毁顺序表
*/
void Destroy_Seq(Seq *s);



#endif

Seq.c

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

Seq *Creat_Seq()
{
	Seq *s = (Seq *)malloc(sizeof(Seq)/sizeof(char));//为线性表分配空间
	if(NULL == s)
		return NULL;
	
	s->data = (Data *)malloc(sizeof(Data)/sizeof(char) * INIT_SIZE);//为数据分配空间
	if(NULL == s->data)
	{
		free(s);
		return NULL;
	}
	
	s->maxSize = INIT_SIZE;
	s->size    = 0;
	
	return s;
}

BOOL Again_Malloc(Seq *s)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	int newsize = sizeof(Data)/sizeof(char) * (s->maxSize + ADD_SIZE);
	Data *p = (Data *)realloc(s->data, newsize);	//用指针p扩展空间
	
	if(NULL == p)		//指针p扩展空间失败时，返回FALSE
	{
		return FALSE;
	}
	
	s->data    	= p;			//将指针p赋值给s->data
	s->maxSize += ADD_SIZE;		//增加maxSize的值
	
	return TRUE;
}

BOOL Insert_Last(Seq *s, Data data)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	if(s->maxSize == s->size)
	{
		if(Again_Malloc(s) != TRUE)
			return FALSE;
	}
	
	s->data[s->size] = data;
	s->size++;
	
	return TRUE;
}

BOOL Insert_Head(Seq *s, Data data)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	if(s->maxSize == s->size)
	{
		if(Again_Malloc(s) != TRUE)
			return FALSE;
	}
	
	int i;
	for(i = s->size; i > 0; i--)
	{
		s->data[i] = s->data[i-1];			//依次后移直到首位
	}
	s->data[0] = data;						//位首位赋值
	s->size++;								//当前空间+1
	
	return TRUE;
}

BOOL Insert_Pos(Seq *s, int pos, Data data)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	if(s->maxSize == s->size)
	{
		if(Again_Malloc(s) != TRUE)
			return FALSE;
	}
	
	int i;
	for(i = s->size; i > pos; i--)
	{
		s->data[i] = s->data[i-1];		//依次覆盖后移知道pos位
	}
	s->data[pos] = data;				//给pos位赋值
	s->size++;							//当前空间+1
	
	return TRUE;
}

BOOL Delete_Pos(Seq *s, int pos)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	
	int i;
	for(i = pos; i < s->size-1; i++)
	{
		s->data[i] = s->data[i+1];		//从下标pos开始依次覆盖前移
	}
	s->size--;							//当前空间-1
	
	return TRUE;
}

BOOL Delete_Data(Seq* s, Data data)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	int i;
	for(i = 0; i < s->size; i++)
	{
		if(s->data[i] == data)
		{
			Delete_Pos(s, i);
			return TRUE;
		}
	}
	
	return FALSE;
}

BOOL Find_Data(Seq* s, Data data, int *pIndex)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	int i;
	for(i = 0; i < s->size; i++)
	{
		if(s->data[i] == data)
		{
			*pIndex = i;
			return TRUE;
		}
	}
	
	return FALSE;
}

BOOL Modify_Data(Seq* s, int index, Data data)
{
	if(NULL == s)
	{
		return ERROR;
	}
	
	if(index < 0 || index >= s->size)
		return FALSE;
	
	s->data[index] = data;
	
	return TRUE;
}

Seq *Merge_Seq(Seq *s1, Seq *s2)
{
	Seq *s3 = (Seq *)malloc(sizeof(Seq)/sizeof(char));//为线性表分配空间
	if(NULL == s3)
		return NULL;
	
	s3->data = (Data *)malloc(sizeof(Data)/sizeof(char) * (s1->size + s2->size));//为数据分配空间
	if(NULL == s3->data)
	{
		free(s3);
		return NULL;
	}
	
	s3->maxSize = s1->size + s2->size;
	s3->size    = s1->size + s2->size;
	
	int i = 0; 		//顺序表s1的下标
	int j = 0;		//顺序表s2的下标
	int k = 0;		//顺序表s3的下标
	
	while(i < s1->size && j < s2->size)
	{
		if(s1->data[i] < s2->data[j])
			s3->data[k++] = s1->data[i++];
		else
			s3->data[k++] = s2->data[j++];
	}
	
	while(i < s1->size)
	{
		s3->data[k++] = s1->data[i++];
	}
	
	while(j < s2->size)
	{
		s3->data[k++] = s2->data[j++];
	}
	
	return s3;
}

void Display_Seq(Seq *s)
{
	if(NULL == s)
	{
		return ;
	}
	
	int i;
	for(i = 0; i < s->size; i++)
	{
		printf("%-4d", s->data[i]);
	}
	printf("\n");
}

void Destroy_Seq(Seq *s)
{
	free(s->data);
	free(s);
}

Josepus_problem.c

#include <stdio.h>
#include "Seq.h"

int main()
{
	Seq *Jos = Creat_Seq();
	int i;
	int num;				//约瑟夫环的总人数
	int delete = 0;			//delete计数到3就删除当前下标
	
	printf("Input the num of people:");
	scanf("%d", &num);
	
	for(i = 1; i <= num; i++)
	{
		Insert_Last(Jos, i);	//初始化编号
	}
	
	Display_Seq(Jos);			//打印初始状态
	
	i = 0;
	while(Jos->size > 1)		//只剩一人时跳出循环
	{
		if(i == Jos->size)		//数到最后一个人就回到首位
		{
			i = 0;
		}
		
		delete++;				//报数+1
		
		if(delete == 3)			
		{
			Delete_Pos(Jos, i);	//报数到3时删除当前下标的人
			delete = 1;			//报数归1
			Display_Seq(Jos);		//每删掉一个人打印一次剩下的人
		}
		i++;
	}
	
	return 0;
}

结果截图：