数据结构与算法-线性表专题(二)-循环单链表

循环单链表

循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。
循环单链表是尾结点的指针域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.插入

特别注意区分头结点

情况1

情况2

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个位置，于是逃过了这场死亡游戏。