循环单链表
循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环。
循环单链表是尾结点的指针域NULL改为指向头结点。
判断空链
head == head->next;
rear == rear->next;
0.数据结构声明
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
/* ElementType类型根据实际情况而定,这里假设为int */
typedef int ElementType;
/* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int Status;
//单链表结构设计
typedef struct Node{
ElementType data;//数据
struct Node *next;//指针域
}Node;
typedef struct Node * SingleCycleLinkList;
1.初始化
Status InitList(SingleCycleLinkList *list){
int item = 0;
SingleCycleLinkList tempNode = NULL;
SingleCycleLinkList targetNode = NULL;
while (1) {
if (*list == NULL) {//空表
//初始化存储空间
*list = (SingleCycleLinkList)malloc(sizeof(Node));
//初始化失败,结束
if(!list) exit(0);
//数据赋值
(*list)->data = item;
//空表指针域指向自己
(*list)->next = *list;
}else{//非空表
int i;
targetNode = *list;
//找到尾结点,使尾结点指向新结点,新结点指向头结点
for (i = 0; targetNode->next != *list;targetNode = targetNode->next,i++)
tempNode = (SingleCycleLinkList)malloc(sizeof(Node));
if (tempNode == NULL) return ERROR;
//数据赋值
tempNode->data = item;
//空表指针域指向头结点
tempNode->next = *list;
//尾结点指向新结点
targetNode->next = tempNode;
}
}
return OK;
}
SingleCycleLinkList list;
InitList(&list);
2.遍历
void Description(SingleCycleLinkList list){
//空链
if (list == NULL){
printf("这是个空链!\n");
}else{
SingleCycleLinkList tempNode;
tempNode = list;
do {
printf("%5d",tempNode->data);
tempNode = tempNode->next;
} while (tempNode != list);
printf("\n");
}
}
SingleCycleLinkList list;
InitList(&list);
Description(list);
3.插入
特别注意区分头结点
Status ListInsert(SingleCycleLinkList *list, int index, int data){
SingleCycleLinkList temp, target;
int i;
if (index == 1) {
//如果插入的位置为1,则属于插入首元结点,所以需要特殊处理
//1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
//2. 找到链表最后的结点_尾结点,
//3. 让新结点的next 执行头结点.
//4. 尾结点的next 指向新的头结点;
//5. 让头指针指向temp(临时的新结点)
temp = (SingleCycleLinkList)malloc(sizeof(Node));
if (temp == NULL) return ERROR;
temp->data = data;
//找到头结点
for (target = *list; target->next != *list; target = target->next);
temp->next = *list;
target->next = temp;
*list = temp;
}else{
//如果插入的位置在其他位置;
//1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
//2. 先找到插入的位置,如果超过链表长度,则自动插入队尾;
//3. 通过target找到要插入位置的前一个结点, 让target->next = temp;
//4. 插入结点的前驱指向新结点,新结点的next 指向target原来的next位置 ;
temp = (SingleCycleLinkList)malloc(sizeof(Node));
if (temp == NULL) return ERROR;
temp->data = data;
for ( i = 1,target = *list; target->next != *list && i != index - 1; target = target->next,i++) ;
temp->next = target->next;
target->next = temp;
}
return OK;
}
int index;
int data;
printf("输入要插入的位置和数据用空格隔开:");
scanf("%d %d",&index,&data);
ListInsert(&list,index,data);
Description(list);
4.删除
Status ListRemove(SingleCycleLinkList *list,int targetIndex){
SingleCycleLinkList temp,target;
int i;
//temp 指向链表首元结点
temp = *list;
if(temp == NULL) return ERROR;
if (targetIndex == 1) {
if ((*list)->next == *list) {//只有一个结点
(*list) = NULL;
return OK;
}
//如果删除的是头结点
//找到尾结点,使尾结点的指针域指向头结点的下一个
//标记当前头结点
temp = *list;
for (target = *list; target->next != *list; target = target->next);
*list = (*list)->next;
target->next = *list;
free(temp);
}else{
//如果删除其他结点--其他结点
//1. 找到删除结点前一个结点target targetIndex-1
//2. 使得target->next 指向下一个结点
//3. 释放需要删除的结点temp
for (i = 1,target = *list; target->next != *list && i != targetIndex-1; target = target->next,i++){
temp = target->next;
target->next = temp->next;
free(temp);
}
}
return OK;
}
printf("输入要删除的位置:");
scanf("%d",&index);
ListRemove(&list, index);
Description(list);
5.查找
int IndexOfValueInList(SingleCycleLinkList list,int value){
if (list == NULL) return -1;
int index = 1;
SingleCycleLinkList tempList = list;
while (tempList->data != value && tempList->next != list) {
index++;
tempList = tempList->next;
}
if (tempList->next == list && tempList->data != value) {
return -1;
}
return index;
}
int targetIndex = -1;
printf("输入要查询的数据:");
scanf("%d",&data);
targetIndex = IndexOfValueInList(list, data);
if(targetIndex != -1){
printf("%d位置是targetIndex = %d\n",data,targetIndex);
}else{
printf("查无此值\n");
}
思考:约瑟夫杀人问题
据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始,越过k-2个人(因为第一个人已经被越过),并杀掉第k个人。接着,再越过k-1个人,并杀掉第k个人。这个过程沿着圆圈一直进行,直到最终只剩下一个人留下,这个人就可以继续活着。问题是,给定了和,一开始要站在什么地方才能避免被处决?Josephus要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,于是逃过了这场死亡游戏。