单项循环列表

typedef int ElemType;
typedef int Status;
//定义结点
typedef struct Node{
    ElemType data;
    structNode *next;
}Node;

typedef struct Node* LinkList;

创建

/*
循环链表创建!
 2种情况:① 第一次开始创建; ②已经创建,往里面新增数据
 
 1. 判断是否第一次创建链表
    YES->创建一个新结点,并使得新结点的next 指向自身; (*L)->next = (*L);
    NO-> 找链表尾结点,将尾结点的next = 新结点. 新结点的next = (*L);
*/
Status CreatList(LinkList *L) {
    
    int item; // 保存数据
    LinkList temp = NULL; // 新创建的节点
    LinkList target = NULL; // 尾节点
    printf("输入节点的值，输入0结束\n");
    while(1) {
        scanf("%d", &item);
        if(item == 0) break;
        
        /*
        若果创建的链表是空，
        01 则创建一个新的节点，
        02 使用next指针指向自己 (*head)->next = *head;
        */
        if (*L == NULL) {
            // 01
            *L = (LinkList)malloc(sizeof(Node));
            if(!L) exit(0);
            (*L)->data = item;
            // 02
            (*L)->next = *L;
        } else {
            /*
            如果链表不空
            01 找到链表的尾节点
            02 创建新节点
            03 使用尾节点的next指向新节点
            04 新节点的next指向头节点
            */
            
            // 01 找到尾节点
            for(target = *L; target->next != *L; target = target->next);
            // 02
            temp = (LinkList)malloc(sizeof(Node));
            if (!temp) return ERROR;
            temp->data = item;
            
            // 03
            target->next = temp;
            
            // 04
            temp->next = *L;
        }
    }
}

Status CreatList2(LinkList *L) {
    
    int item; // 保存数据
    LinkList *temp = NULL; // 新创建的节点
    LinkList *tail = NULL; // 尾节点
    printf("输入节点的值，输入0结束\n");
    while(1) {
        scanf("%d", &item);
        if(item == 0) break;
        
        /*
        若果创建的链表是空，
        01 则创建一个新的节点，
        02 使用next指针指向自己 (*head)->next = *head;
        03 尾节点->next = 头节点
        */
        if(*L == NULL) {
            // 01
            *L = (LinkList)malloc(sizeof(Node));
            if(!*L) return ERROR;
            (*L)->data = item;
            // 02
            (*L)->next = *L;
            // 03
            tail = *L;
        } else {
        
            /*
            如果链表不空
            01 找到链表的尾节点
            02 尾节点->next = 新节点
            03 新节点->next = 头节点
            04 尾节点指向新节点
            */
            // 01
            temp = (LinkList)malloc(sizeof(Node));
            if(!temp) return ERROR;
            temp->next = item;
            
            // 02
            tail->next = temp;
            
            // 03
            temp->next = *L;
            
            // 04
            tail = temp;
        }
    }
}

遍历

void Show(LinkList L) {
    if(p == NULL) {
        printf("打印的链表为空!\n");
        return 
    }
    
    LinkList temp = L;
    do {
        printf("%5d",temp->data);
        temp = temp->next;
    } while(temp != L)
    printf("\n")
}

插入

Status LinkInsert(LinkList *L, int place, int num) {
    LinkList temp, target;
    int i;
    if(place == 1) {
        //如果插入的位置为1,则属于插入首元结点,所以需要特殊处理
        //1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
        //2. 找到链表最后的结点_尾结点,
        //3. 让新结点的next 执行头结点.
        //4. 尾结点的next 指向新的头结点;
        //5. 让头指针指向temp(临时的新结点)
        
        temp = (LinkList)malloc(sizeof(Node));
        if(!temp) return ERROR;
        temp->data = num;
        
        for(target = *L; target->next != *L; target = target->next);
        temp->next = *L;
        target->next = *L;
        *L = temp;
    } else {
        
        temp = (LinkList)malloc(sizeof(Node));
        if(!temp) return ERROR;
        temp->data = num;
        
        for(i = 1, target = *L; target->next != *L &&  i != place - 1; target = target->next, i++);
        
        temp->next = target->next;
        target->next = temp;
    }
}

删除

Status LinkListDelete(LinkList *L int place) {
    LinkList temp = NULL;
    LinkList target = NULL:
    
    temp = *L;
    if(!temp) return ERROR;
    
    if (place == 1) {
        // ①.如果删除到只剩下首元结点了,则直接将*L置空;
        
        if((*L)->next == (*L)) {
            (*L) = NULL;
            return OK;
        }
        
        //②.链表还有很多数据,但是删除的是首结点;
        //1. 找到尾结点, 使得尾结点next 指向头结点的下一个结点 target->next = (*L)->next;
        //2. 新结点做为头结点,则释放原来的头结点
        
        for(target = *L; target->next != *L; target = target->next);
        temp = *L;
                       
        *L = (*L)->next; 
        target->next = (*L);
        free(temp);
    } else {
        //如果删除其他结点--其他结点
        //1. 找到删除结点前一个结点target
        //2. 使得target->next 指向下一个结点
        //3. 释放需要删除的结点temp
        
        for(int = 1, target = *L; target->next != *L && i != place - 1; target = target->next, i++);
        
        temp = target->next;
        target->next = temp->next;
        free(temp);
    }
}

查询

int FindValue(LinkList L, int value) {
    int i = 1;
    LinkList temp = NULL;
    temp = L;
    
    //当尾结点指向头结点就会直接跳出循环,所以要额外增加一次判断尾结点的data == value;
    if(temp->next == L && temp->data != value) {
        return -1;
    }
    
    //寻找链表中的结点 data == value
    while(temp->data ! = value && temp->next != L) {
        i++;
        temp = temp->next;
    }
    
    return i;
}