线性表->链式存储->循环链表

文字描述

　　循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。由此，从表中任一结点出发均可找到表中其他结点。

示意图

算法分析

插入、删除、查找等同单链表。

代码实现

//
// Created by lady on 19-1-27.
//

#include <stdio.h>
#include <stdlib.h>

//线性表的单向循环链表存储结构
typedef struct ElemType{
    char data[10];
}ElemType;
typedef struct CNode{
    ElemType e;
    struct CNode *next;
}CNode;
typedef struct {
    CNode *head;//指向第一个指针
    CNode *tail;//指向最后一个指针
    int length;//表示链表数据元素个数
}CLinkNode, *CLinkList;

//构造一个空的线性表
static int InitList_CL(CLinkList *L)
{
    (*L) = (CLinkList)malloc(sizeof(CLinkNode));
    (*L)->length = 0;
    (*L)->head = NULL;
    (*L)->tail = NULL;
}

//销毁线性表
static int Destory_CL(CLinkList *L)
{
    if(L == NULL || (*L) == NULL){
        return -1;
    }
    CNode *p = (*L)->head;
    CNode *q;
    while(p){
        q = p;
        p = p->next;
        free(q);
        if(p == (*L)->head)
            break;
    }
    free(*L);
    (*L) = NULL;
}

//返回1表示空， 0表示非空
static int ListEmpty_CL(CLinkList L)
{
    return L->length ? 0: 1;
}

//返回线性表L中的数据元素个数
static int ListLength_CL(CLinkList L)
{
    return L->length;
}

//在线性表末尾插入数据元素e
static int ListInsert_CL(CLinkList *L,ElemType e)
{
    CNode *new = (CNode *)malloc(sizeof(CNode));
    if(new == NULL){
        return -1;
    }
    CNode *p;
    new ->e = e;
    new->next = NULL;
    if(ListEmpty_CL(*L)){
        (*L)->length += 1;
        new->next = new;
        (*L)->head = new;
        (*L)->tail = new;
    }else{
        (*L)->length +=1;
        new->next = (*L)->head;
        (*L)->tail->next = new;
        (*L)->tail = new;
    }
    return 0;
}

//删除L中的第loc个数据元素，并将被删元素的值存放在e中
static int ListDelete_CL(CLinkList *L, int loc, ElemType *e)
{
    CNode *p = (*L)->head;
    CNode *q = NULL;
    int i = 1;
    int f = 0;
    while(p){
        if(i == loc){
            f = 1;
            break;
        }
        i += 1;
        q = p;
        p = p->next;
        if(p == (*L)->head){
            f = -1;
            break;
        }
    }
    if(f<1)
        return -1;
    (*L)->length -= 1;
    (*e) = p->e;
    if((*L)->length == 0){
        free(p);
        (*L)->head = NULL;
        (*L)->tail = NULL;
    }
    if(q == NULL){
        q = p->next;
        free(p);
        (*L)->tail->next = q;
    }else{
        q->next = p->next;
        free(p);
    }
    return 0;
}

//依次对L的每个数据元素调用函数fun
static int ListTraverse_CL(CLinkList L, int (*fun)(ElemType,int), char note[])
{
    printf("遍历循环链表%s:", note);
    CNode *p = L->head;
    int i = 0;
    while(p){
        if(fun(p->e, ++i)){
            return -1;
        }
        p = p->next;
        if(p == L->head)
            break;
    }
    printf("
");
    return 0;
}

static int print(ElemType e, int loc)
{
    printf("%3d=%-10s", loc, e.data);
    return 0;
}

//创建一个长度为n的链表
static int CreateList_CL(CLinkList *L, int n, char note[])
{
    printf("创建一个长度为%d的循环链表%s!
", n, note);
    InitList_CL(L);
    ElemType e;
    int i = 0;
    for(i=0; i<n; i++){
        printf("输入第%d个元素:", i+1);
        scanf("%s[^\n]", e.data);
        ListInsert_CL(L, e);
    }
}

int main(int argc, char *argv[])
{
    CLinkList L;
    ElemType e;
    int location = 0;

    CreateList_CL(&L, 5, "L:");
    ListTraverse_CL(L, print, "L");

    printf("输入删除元素的位置:");
    scanf("%d", &location);
    ListDelete_CL(&L, location, &e);
    printf("位于%d的元素%s已经从循环链表中被删除！
", location, e.data);
    ListTraverse_CL(L, print, "L");

    Destory_CL(&L);
    return 0;
}

代码运行

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
创建一个长度为5的循环链表L:!
输入第1个元素:WU
输入第2个元素:ZHENG
输入第3个元素:WANG
输入第4个元素:SUN
输入第5个元素:LI
遍历循环链表L:  1=WU          2=ZHENG       3=WANG        4=SUN         5=LI        
输入删除元素的位置:2
位于2的元素ZHENG已经从循环链表中被删除！
遍历循环链表L:  1=WU          2=WANG        3=SUN         4=LI        

Process finished with exit code 0