/*国嵌版的循环*/
#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_
typedef void CircleList;
typedef struct _tag_CircleListNode CircleListNode;
struct _tag_CircleListNode
{
CircleListNode* next;
};
CircleList* CircleList_Create();
void CircleList_Destroy(CircleList* list);
void CircleList_Clear(CircleList* list);
int CircleList_Empty(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
<pre name="code" class="cpp">#include <stdio.h>
#include <malloc.h>
#include "CircleList.h"
typedef struct _tag_CircleList
{
CircleListNode header;
int length;
CircleListNode* slider; //游标
} TCircleList;
CircleList* CircleList_Create()
{
TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
if(ret != NULL)
{
ret->header.next = NULL;
ret->length = 0;
ret->slider = NULL;
}
return ret;
}
void CircleList_Destroy(CircleList* list)
{
free(list);
}
void CircleList_Clear(CircleList* list)
{
TCircleList* slist = (TCircleList*)list;
if(slist != NULL)
{
slist->header.next = NULL;
slist->length = 0;
slist->slider = NULL;
}
}
int CircleList_Empty(CircleList* list)
{
TCircleList* slist = (TCircleList*)list;
int ret = 0;
if((slist != NULL) && (slist->length == 0) && (slist->slider == NULL))
{
ret = 1;
}
return ret;
}
int CircleList_Length(CircleList* list)
{
TCircleList* slist = (TCircleList*)list;
int ret = -1;
if(slist != NULL)
{
ret = slist->length;
}
return ret;
}
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
TCircleList* slist = (TCircleList*)list;
int i = 0;
int ret = (slist != NULL) && (0 <= pos);
if(ret)
{
CircleListNode* current = (CircleListNode*)slist;
for(i=0;(i < pos) && (current->next != NULL);i++)
{
current = current->next;
}
node->next = current->next;
current->next = node;
//判断是否是在空的时候插入节点
if(slist->length == 0)
{
slist->slider = node;
node->next = node;
}
slist->length++;
//重新设置尾结点的指向第0个节点
if(current == (CircleListNode*)slist)
{
CircleListNode* last = CircleList_Get(list,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(0 <= pos)
{
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) && (0 <= pos)&& (slist->length > 0)) //提高健壮性
{
CircleListNode* current = (CircleListNode*)slist;
CircleListNode* first = (CircleListNode*)CircleList_Get(list,0);
CircleListNode* last = (CircleListNode*)CircleList_Get(list,slist->length-1); //提高效率;
for(i=0;i<pos;i++)
{
current = current->next;
}
ret = current->next;
current->next = ret->next;
//判断删除的是否是第一个元素
if(ret == first)
{
slist->header.next = ret->next;
last->next = ret->next;
}
slist->length--;
//判断删除的与游标使用同一个节点 ,slider指向删除结点的下一个
if(slist->slider == ret)
{
slist->slider = ret->next;
}
//判断链表是否为空
if(slist->length == 0)
{
slist->header.next = NULL;
slist->slider == NULL;
}
}
return ret;
}
CircleListNode* CircleList_DeleteNode(CircleList* list,CircleListNode* node)
{
TCircleList* slist = (TCircleList*)list;
CircleListNode* ret = NULL;
int i=0;
if(slist != NULL)
{
CircleListNode* current = (CircleListNode*)slist;
printf("current->next:0x%x, slist->header.next:0x%x",current->next, slist->header.next);
for(i=0;i<slist->length;i++)
{
if(current->next == node)
{
ret = current->next;
break;
}
current = current->next;
}
if( ret != NULL)
{
CircleList_Delete(list,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;
}
/******************************************
*Function :实现约瑟夫问题
*
******************************************/
/*****************************************/
#include <stdio.h>
#include <stdlib.h>
#include "CircleList.h"
struct Value
{
CircleListNode header;
int v;
};
int main(int argc, char *argv[])
{
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, 5);
// CircleList_Delete(list, 0);
for(i=0; i<2*CircleList_Length(list); i++)
{
struct Value* pv = (struct Value*)CircleList_Get(list, i);
printf("%d\n", pv->v);
}
printf("\n");
while( CircleList_Length(list) > 0 )
{
struct Value* pv = (struct Value*)CircleList_Delete(list, 0);
printf("%d\n", pv->v);
}
printf("\n");
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");
struct Value* pv = (struct Value*)CircleList_Reset(list);
printf("%d\n", pv->v);
printf("length is %d\n",CircleList_Length(list));
printf("\n");
while( CircleList_Length(list) > 0 )
{
struct Value* pv = NULL;
for(i=1; i<3; i++)
{
printf("enter\n");
pv = (struct Value*) CircleList_Next(list);
printf("%d\n",pv->v);
printf("end\n");
}
pv = (struct Value*)CircleList_Current(list);
printf("即将删除的元素%d\n", pv->v);
pv = (struct Value*)CircleList_DeleteNode(list, (CircleListNode*)pv);
printf("删除的元素%d\n", pv->v);
}
printf("the list is Empty(%d)\n",CircleList_Empty(list));
printf("\n");
CircleList_Destroy(list);
return 0;
}
/********************************************************************/
/******************************************
*Function :实现约瑟夫问题
*
******************************************
#include <stdio.h>
#include <stdlib.h>
#include "CircleList.h"
typedef struct value
{
CircleListNode header;
char c;
} DataElem;
int main(int argc, char *argv[])
{
printf("约瑟夫问题\n");
DataElem d1,d2,d3,d4,d5,d6,d7,d8;
d1.c = '1';
d2.c = '2';
d3.c = '3';
d4.c = '4';
d5.c = '5';
d6.c = '6';
d7.c = '7';
d8.c = '8';
CircleList_Insert(list,(CircleListNode*)&d1,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d2,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d3,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d4,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d5,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d6,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d7,CircleList_Length(list));
CircleList_Insert(list,(CircleListNode*)&d8,CircleList_Length(list));
for(i=0;i<CircleList_Length(list);i++)
{
DataElem* p = (DataElem*)CircleList_Current(list);
CircleList_Next(list);
printf("the element is %c\n",p->c);
}
printf("the length is %d\n",CircleList_Length(list));
while( CircleList_Length(list) > 0 )
{
DataElem* p = NULL;
for(i=1; i<3; i++)
{
CircleList_Next(list);
}
p = (DataElem*)CircleList_Current(list);
printf("%c\n", p->c);
CircleList_DeleteNode(list, (CircleListNode*)p);
}
printf("\n");
CircleList_Destroy(list);
return 0;
}
*************************************************************/
#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定,这里假设为int */
Status visit(ElemType c)
{
printf("%d ",c);
return OK;
}
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */
/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
*L=(Node*)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
if((*L) == NULL) /* 存储分配失败 */
return ERROR;
(*L)->next=NULL; /* 指针域为空 */
return OK;
}
/* 初始条件:顺序线性表L已存在。操作结果:若L为空表,则返回TRUE,否则返回FALSE */
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE;
else
return TRUE;
}
/* 初始条件:顺序线性表L已存在。操作结果:将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q,start;
start = (*L)->next; /*记录第0个结点*/
p=(*L)->next; /* p指向第0个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
if(q == start)
{
break;
}
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}
/* 初始条件:顺序线性表L已存在。操作结果:返回L中数据元素个数 */
int ListLength(LinkList L)
{
int i=0;
Node* start = L->next; /*记录第0个结点*/
Node* p=L->next; /* p指向第0个结点 */
while(p)
{
i++;
p=p->next;
if(p == start)
{
break;
}
}
return i;
}
/* 初始条件:顺序线性表L已存在,0≤i<ListLength(L) */
/* 操作结果:用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int pos,ElemType *e)
{
int i;
if(0 <= pos && pos<ListLength(L))
{
Node *current = L->next; /*指向第0个结点*/
for(i=0; i< pos && current->next != NULL ;i++)
{
current = current->next;
}
*e = current->data;
return OK;
}
return ERROR;
}
/* 初始条件:顺序线性表L已存在 */
/* 操作结果:返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在,则返回值为-1*/
int LocateElem(LinkList L,ElemType e)
{
int i=0;
Node *current = L->next;
while(current)
{
if(current->data==e) /* 找到这样的数据元素 */
return i;
current=current->next;
i++;
}
return -1;
}
/* 初始条件:顺序线性表L已存在,0≤i<ListLength(L), */
/* 操作结果:在L中第pos个位置之前插入新的数据元素e,L的长度加1 */
Status ListInsert(LinkList *L,int pos,ElemType e)
{
int i;
int length = ListLength(*L);
Node *tmp = *L;
// printf("length:%d\n", length);
if(0 <= pos && L!=NULL)
{
Node *current = *L; /*current是头结点,指向第0个节点*/
if(pos>=ListLength(*L))
{
pos = ListLength(*L);
}
for(i=0; i<ListLength(*L);i++)
{
tmp = tmp->next;
}
Node *end = tmp;
for(i=0; i< pos && current->next != NULL ;i++)
{
current = current->next;
}
// printf("current->next:0x%x\n", current->next);
Node *Next = current->next;
Node *s = (Node*)malloc(sizeof(Node));
// printf("s:0x%x\n", s);
s->data = e;
s->next = Next;
current->next = s;
end->next = s;
// printf("OVER:currentt:0x%x\n", current);
// printf("OVER:current->next:0x%x\n", current->next);
if(length == 0)
{
s->next = s;
}
return OK;
}
return ERROR;
}
/* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */
/* 操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1 */
Status ListDelete(LinkList *L,int pos,ElemType *e)
{
int i;
if(0 <= pos && pos < ListLength(*L)&& L!=NULL && e != NULL)
{
Node *current = *L; /*current是头结点,指向第0个节点*/
Node *tmp = *L;
Node *start = (*L)->next;
for(i=0; i<ListLength(*L);i++)
{
tmp = tmp->next;
}
Node *end = tmp;
for(i=0; i< pos && current->next != NULL ;i++)
{
current = current->next;
}
Node *Next = current->next;
*e = Next->data;
current->next = Next->next;
//判断删除的是否是第一个元素
if(start == Next)
{
end->next = Next->next;
}
free(Next);
return OK;
}
return ERROR;
}
/* 初始条件:顺序线性表L已存在 */
/* 操作结果:依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
int i=0;
LinkList p=L->next;
while(p && i<ListLength(L))
{
visit(p->data);
p=p->next;
i++;
}
printf("\n");
return OK;
}
#if 0
/* 随机产生n个元素的值,建立带表头结点的单链线性表L(头插法) */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}
/* 随机产生n个元素的值,建立带表头结点的单链线性表L(尾插法) */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}
#endif
int main()
{
LinkList L;
ElemType e;
Status i;
int j,k;
i=InitList(&L);
printf("初始化L后:ListLength(L)=%d\n",ListLength(L));
for(i=0;i<5;i++)
ListInsert(&L,0,i);
//printf("\n");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
i=ListEmpty(L);
printf("L是否空:i=%d(1:是 0:否)\n",i);
i=ClearList(&L);
printf("清空L后:ListLength(L)=%d\n",ListLength(L));
i=ListEmpty(L);
printf("L是否空:i=%d(1:是 0:否)\n",i);
for(j=1;j<=10;j++)
ListInsert(&L,j-1,j);
printf("在L的表尾依次插入1~10后:L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
ListInsert(&L,0,0);
printf("在L的表头插入0后:L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
GetElem(L,5,&e);
printf("第5个元素的值为:%d\n",e);
for(j=3;j<=4;j++)
{
k=LocateElem(L,j);
if(k)
printf("第%d个元素的值为%d\n",k,j);
else
printf("没有值为%d的元素\n",j);
}
k=ListLength(L); /* k为表长 */
for(j=k+1;j>=k;j--)
{
i=ListDelete(&L,j,&e); /* 删除第j个数据 */
if(i==ERROR)
printf("删除第%d个数据失败\n",j);
else
printf("删除第%d个的元素值为:%d\n",j,e);
}
printf("依次输出L的元素:");
ListTraverse(L);
j=5;
ListDelete(&L,j,&e); /* 删除第5个数据 */
printf("删除第%d个的元素值为:%d\n",j,e);
printf("依次输出L的元素:");
ListTraverse(L);
i=ClearList(&L);
printf("\n清空L后:ListLength(L)=%d\n",ListLength(L));
#if 0
CreateListHead(&L,20);
printf("整体创建L的元素(头插法):");
ListTraverse(L);
i=ClearList(&L);
printf("\n删除L后:ListLength(L)=%d\n",ListLength(L));
CreateListTail(&L,20);
printf("整体创建L的元素(尾插法):");
ListTraverse(L);
#endif
return 0;
}