数据结构 - 循环链表 （约瑟夫问题）

A- A+
流沙团 • • 数据结构 • 4988View 0

文件：

circleclist.h

circlelist.c

test01.c

约瑟夫.c

-------------------------------------------

circleclist.h 


#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;

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

CircleList* CircleList_Create();

void List_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);

//add

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

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif


-------------------------------------------

circlelist.c 


#include <stdio.h>
#include <malloc.h>
#include "CircleList.h"

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

//创建头，用于存储信息。
CircleList* CircleList_Create() // O(1)
{
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) // O(1)
{
if (list == NULL)
{
return;
}
free(list);
}

//链表清理
void CircleList_Clear(CircleList* list) // O(1)
{
TCircleList* sList = (TCircleList*)list;
if (sList == NULL)
{
return;
}
sList->length = 0;
sList->header.next = NULL;
sList->slider = NULL;
}

//链表的长度
int CircleList_Length(CircleList* list) // O(1)
{
TCircleList* sList = (TCircleList*)list;
int ret = -1;
if (list == NULL)
{
return ret;
}
ret = sList->length;
return ret;
}

//节点插入
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)
{
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++;

//若头插法
if (current == (CircleListNode*)sList)
{
//获取最后一个元素
CircleListNode* last = CircleList_Get(sList, sList->length - 1);
last->next = current->next; //3
}
}

return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
int i = 0;

if (list == NULL || pos < 0)
{
return NULL;
}
//if( (sList != NULL) && (pos >= 0) && (sList->length > 0) )
{
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) // O(n)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
int i = 0;

if ((sList != NULL) && (pos >= 0) && (sList->length > 0))
{
CircleListNode* current = (CircleListNode*)sList;
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;
}

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node) // O(n)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
int i = 0;

if (sList != NULL)
{
CircleListNode* current = (CircleListNode*)sList;

//查找node在循环链表中的位置i
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) // O(1)
{
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) // O(1)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;

if (sList != NULL)
{
ret = sList->slider;
}

return ret;
}

CircleListNode* CircleList_Next(CircleList* list) // O(1)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;

if ((sList != NULL) && (sList->slider != NULL))
{
ret = sList->slider;
sList->slider = ret->next;
}

return ret;
}

-------------------------------------------

test01.c 


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


struct Value
{
CircleListNode circlenode;
int v;
};

int main01(int argc, char *argv[])
{
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;

int i = 0;

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, 0);
CircleList_Insert(list, (CircleListNode*)&v2, 0);
CircleList_Insert(list, (CircleListNode*)&v3, 0);
CircleList_Insert(list, (CircleListNode*)&v4, 0);

for (i = 0; i<2 * CircleList_Length(list); i++)
{
struct Value* pv = (struct Value*)CircleList_Get(list, i);

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

while (CircleList_Length(list) > 0)
{
CircleList_Delete(list, 0);
}

printf("\n");

CircleList_Destroy(list);

system("pause");

return 0;
}


-------------------------------------------

约瑟夫.c 


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


struct Value
{
CircleListNode header;
int v;
};

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


struct Value v1, v2, v3, v4, v5, v6, v7, 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_Next(list);
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);

system("pause");
return;
}









原文链接： 数据结构 - 循环链表 （约瑟夫问题） 版权所有，转载时请注明出处，违者必究。
注明出处格式：流沙团 ( https://gyarmy.com/post-21.html )

发表评论

0则评论给“数据结构 - 循环链表 （约瑟夫问题）”