数据结构-循环链表

#ifndef __CIRCLELIST_H_
#define __CIRCLELIST_H_
typedef void CircleList;
typedef struct _tag_CircleListNode
{
struct _tag_CircleListNode *next;
}CircleListNode;
/*循环链表的创建*/
CircleList* CircleList_Create();
/*循环链表的销毁*/
void CircleList_Destory(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);

/*new add*/
/*指定节点地址删除*/
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif

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

typedef struct _tag_TCircleList
{
CircleListNode header;
CircleListNode* cursor;
int length;

}TCircleList;

/*循环链表的创建*/
CircleList* CircleList_Create()
{
TCircleList* tlist = (TCircleList*)malloc(sizeof(TCircleList));
if (tlist == NULL)
{
printf("创建失败%d", -1);
return NULL;
}
memset(tlist, 0, sizeof(TCircleList));
tlist->length = 0;
tlist->header.next = NULL;
tlist->cursor = NULL;
return tlist;
}
/*循环链表的销毁*/
void CircleList_Destory(CircleList* list)
{
if (list == NULL)
{
return;
}
free(list);
list = NULL;
}
/*循环链表的清空*/
void CircleList_Clear(CircleList* list)
{
if (list == NULL)
{
return;
}
TCircleList *tlist = (TCircleList*)list;
tlist->length = 0;
tlist->header.next = NUL
4000
L;
tlist->cursor = NULL;
}
/*循环链表的求长度*/
int CircleList_Length(CircleList* list)
{
if (list == NULL)
{
return -1;
}
TCircleList *tlist = (TCircleList*)list;
return tlist->length;
}
/*循环链表的求插入*/
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
if (list == NULL || node == NULL || pos < 0)
{
return -1;
}
TCircleList *tlist = (TCircleList*)list;
if (pos>tlist->length)
{
return -2;
}
if (tlist->length == 0)
{
tlist->header.next = node;
node->next = node;
tlist->length++;
return 0;
}
if (tlist->length > 0)
{
if (pos == 0)
{
CircleListNode *EndNode = tlist->header.next;
while (EndNode->next != tlist->header.next)
{
EndNode = EndNode->next;
}
node->next = tlist->header.next;
tlist->header.next = node;
EndNode->next = node;
tlist->length++;
return 0;
}
if (pos > 0)
{
CircleListNode *pCur = tlist;
while (pCur&&pos--)
{
pCur = pCur->next;
}
if (pCur == NULL)
{
return -2;
}
node->next = pCur->next;
pCur->next = node;
tlist->length++;
return 0;
}
}
}
/*循环链表的求某节点*/
CircleListNode* CircleList_Get(CircleList* list, int pos)
{
if (list == NULL || pos < 0)
{
return NULL;
}
TCircleList *tlist = list;
CircleListNode *pCur = tlist;
while (pos--)
{
pCur = pCur->next;
}
return pCur->next;

}
/*循环链表的删除节点*/
CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
if (list == NULL || pos < 0)
{
return NULL;
}
TCircleList* tlist = list;
if (tlist->length == 0)return NULL;
if (pos >= tlist->length)return NULL;
if (pos == 0)
{

/*处理游标*/
CircleListNode *DelNode = tlist->header.next;
if (tlist->cursor == DelNode)
{
tlist->cursor = tlist->cursor->next;
}
/*删除处理*/
CircleListNode *EndNoed = tlist->header.next;
while (EndNoed->next != tlist->header.next)
{
EndNoed = EndNoed->next;
}
tlist->header.next = tlist->header.next->next;
EndNoed->next = tlist->header.next;
tlist->length--;
return DelNode;
}
if (pos<tlist->length)
{

CircleListNode *pCur = tlist;
while (pCur&&pos--)
{
pCur = pCur->next;
}
CircleListNode *DelNode = pCur->next;
/*处理游标*/
if (tlist->cursor == DelNode)tlist->cursor = tlist->cursor->next;
pCur->next = DelNode->next;
tlist->length--;
if (tlist->length == 0)
{
tlist->header.next = NULL;
tlist->cursor = NULL;
}
return DelNode;
}
}
/*指定节点地址删除*/
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
if (list == NULL || node == NULL)
{
return NULL;
}
TCircleList *tlist = list;
int pos = 0;
CircleListNode* tmp = tlist;
while (tmp->next != node)
{
tmp = tmp->next;
pos++;
}
return CircleList_Delete(list, pos);
}
/*重置游标*/
CircleListNode* CircleList_Reset(CircleList* list)
{
if (list == NULL)
{
return NULL;
}
TCircleList *tlist = list;
tlist->cursor = tlist;
}
/*返回游标*/
CircleListNode* CircleList_Current(CircleList* list)
{
if (list == NULL)
{
return NULL;
}
TCircleList *tlist = list;
return (tlist->cursor);
}
/*游标下移*/
CircleListNode* CircleList_Next(CircleList* list)
{
if (list == NULL)
{
return NULL;
}
TCircleList *tlist = list;
CircleListNode *tmp = tlist->cursor;
tlist->cursor = tlist->cursor->next;
return tmp;
}

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

typedef struct teacher
{
CircleListNode node;
int age;
}T;

int main()
{
T t1, t2, t3, t4, t5,t6,t7,t8;
t1.age = 1;
t2.age = 2;
t3.age = 3;
t4.age = 4;
t5.age = 5;
t6.age = 6;
t7.age = 7;
t8.age = 8;

CircleList *list = CircleList_Cr
c840
eate();
CircleList_Insert(list, &t8, 0);
CircleList_Insert(list, &t7, 0);
CircleList_Insert(list, &t6, 0);
CircleList_Insert(list, &t5, 0);
CircleList_Insert(list, &t4, 0);
CircleList_Insert(list, &t3, 0);
CircleList_Insert(list, &t2, 0);
CircleList_Insert(list, &t1, 0);

T *tmp = NULL;
//int i = 0;
//for (i = 0; i < CircleList_Length(list); i++)
//{
//  tmp = CircleList_Get(list, i);
//  printf("%d\n", tmp->age);
//}
int len = CircleList_Length(list);
CircleList_Reset(list);
CircleList_Next(list);

int i = 1;
while (CircleList_Length(list)  != 0)
{
tmp = CircleList_Current(list);
if (i == 3)
{
printf("%d\n", tmp->age);
CircleList_DeleteNode(list, tmp);
i = 1;
}
else
{
CircleList_Next(list);
i++;
}
}

return 0;
}