【数据结构】 循环单链表的基本操作 （C语言版）

于 2024-01-21 20:24:54 发布
阅读量717 收藏 21
点赞数 10
文章标签： 数据结构 c语言 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56814370/article/details/135734041
版权

目录

一、循环单链表

1、循环单链表的定义：

2、循环单链表的优缺点：

二、循环单链表的基本操作算法（C语言）  

 1、宏定义

 2、创建结构体

3、循环单链表的初始化 

4、循环单链表的插入

5、求单链表长度

6、循环单链表的清空

7、循环单链表的销毁

8、循环单链表的取值

9、循环单链表的查找

10、循环单链表的删除

11、头插法创建循环链表

12、尾插法创建循环链表

13、输出链表元素

三、循环单链表的基本操作完整代码（C语言）

四、运行结果

一、循环单链表

1、循环单链表的定义：

循环单链表是一种特殊类型的单链表，其特点是链表的最后一个结点的指针域指向整个链表的第一个结点，从而形成一个环状结构。

这种数据结构可以用来存储有序的数据集合，其插入和删除操作可以在平均时间复杂度O(1)内完成，这是其相比单链表的一大优势。循环单链表的操作一般更复杂，因为需要维护环状的结构，并保证对链表的操作满足时间复杂度的要求。

2、循环单链表的优缺点：

优点：

  1. 循环单链表可以高效地执行插入和删除操作，因为不需要像单链表那样从头或尾部开始遍历整个链表。
  2. 循环单链表的空间利用率较高，因为最后一个结点的指针域指向整个链表的第一个结点，从而避免了浪费空间存储空指针。
  3. 循环单链表适合用于处理有序的数据集合，可以快速地执行查找、插入和删除操作。

缺点：

  1. 循环单链表的操作相对复杂，因为需要维护环状的结构，并保证对链表的操作满足时间复杂度的要求。
  2. 在某些情况下，循环单链表可能比单链表更难以理解和实现。

二、循环单链表的基本操作算法（C语言）  

 1、宏定义
#define OK 1
#define ERROR 0

typedef char ElemType;
typedef int Status;
 2、创建结构体
typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;
3、循环单链表的初始化 
//循环链表初始化
Status InitList(LinkList &head) {
    head = new LNode;
    //head->next=NULL;
    head->next = head;
    return OK;
}
4、循环单链表的插入
//插入
Status ListInsert(LinkList &head, int i, ElemType e) {
    LinkList p = head;
    int j = 0;
    while (p && (j < i - 1)) {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1) {
        return ERROR;
    }

    LNode *s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;

    return OK;
}
5、求单链表长度
//求单链表长度
Status GetLinkListLength(LinkList head) {
    LinkList p = head->next;
    int length = 0;
    while (p != head) {   //p!=NULL          //单链表不为空表时
        length++;
        p = p->next;
    }
    return length;
}
6、循环单链表的清空
//清空
Status ClearLinkList(LinkList &head) {
    LinkList p = head->next;
    LinkList q;
    while (p != head) { //p != L  p!=NULL
        q = p;
        p = p->next;
        delete q;
    }
    head->next = head; //链表为空
    return OK;
}
7、循环单链表的销毁
//销毁
Status DestoryLinkList(LinkList &head) {
    LinkList p = head->next;
    LinkList q;
    while (p != head) { //p != L  p!=NULL
        q = p;
        p = p->next;
        delete q;
    }
    head->next = NULL;
    // printf("\n销毁成功\n");
    return OK;
}
8、循环单链表的取值
//取值
Status GetLinkList(LinkList head, int i, ElemType &e) {
    LinkList p = head->next;
    int j = 1;
    while (p != head && j < i) {  //p != L
        p = p->next;
        j++;
    }
    if (p == head) {//p==L
        return ERROR;
    }
    e = p->data;

    return OK;
}
9、循环单链表的查找
//查找
int LocateLinkListElem(LinkList head, ElemType e) {
    LinkList p = head->next;
    int j = 1;
    while (p != head && (p->data != e)) {//p != L p!=NULL
        p = p->next;
        j++;
    }
    if (p == head) { //p==L  !p<=>p==NULL
        return 0;
    }
    return j;
}
10、循环单链表的删除
//删除
Status ListDelete(LinkList &head, int i, ElemType &e) {
    LinkList p = head;
    int j = 0;
    while (p->next != head && j < i - 1) {  //p != L
        p = p->next;
        j++;
    }
    if (p->next == head) { //p==L
        return ERROR;
    }
    LinkList q = p->next;
    e = q->data;
    p->next = q->next;
    delete q;
    return OK;
}
11、头插法创建循环链表
//头插法创建循环链表
void CreateLinkList_H(LinkList &head, int n) {
    InitList(head);
    for (int i = 0; i < n; i++) {
        LNode *p = new LNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        p->next = head->next;
        head->next = p;
    }
}
12、尾插法创建循环链表
//尾插法创建循环链表
void CreateLinkList_R(LinkList &head, int n) {
    InitList(head);
    LinkList r = head;
    for (int i = 0; i < n; i++) {
        LNode *p = new LNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        //p->next=NULL   p->next=head
        //p->next = r->next;
        r->next = p;
        r = p;
    }
    r->next = head;                //尾结点next域指向头结点
}
13、输出链表元素
//输出链表元素
void printLinkList(LinkList head) {
    LinkList p = head->next;
    while (p != head) { //p != L
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}

三、循环单链表的基本操作完整代码（C语言）

#include <stdio.h>
#include <conio.h>//getche()
#include <cstdlib>//free()

#define OK 1
#define ERROR 0

typedef char ElemType;
typedef int Status;

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

//循环链表初始化
Status InitList(LinkList &head) {
    head = new LNode;
    //head->next=NULL;
    head->next = head;
    return OK;
}

//功能菜单
Status choice() {
    printf("==================================\n");
    printf("         循环链表操作功能菜单        \n");
    printf("1、插入元素  2、查询表长  3、按位查找\n");
    printf("4、按值查找  5、删除元素  6、销毁链表\n");
    printf("7、清空链表  8、批量插入  9、链表元素\n");
    printf("10、头插法创建单链表11、尾插法创建单链表\n");
    printf("==================================\n");
    return 1;
}

//插入
Status ListInsert(LinkList &head, int i, ElemType e) {
    LinkList p = head;
    int j = 0;
    while (p && (j < i - 1)) {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1) {
        return ERROR;
    }

    LNode *s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;

    return OK;
}

//求单链表长度
Status GetLinkListLength(LinkList head) {
    LinkList p = head->next;
    int length = 0;
    while (p != head) {   //p!=NULL          //单链表不为空表时
        length++;
        p = p->next;
    }
    return length;
}


//销毁
Status DestoryLinkList(LinkList &head) {
    LinkList p = head->next;
    LinkList q;
    while (p != head) { //p != L  p!=NULL
        q = p;
        p = p->next;
        delete q;
    }
    head->next = NULL;
    // printf("\n销毁成功\n");
    return OK;
}


//清空
Status ClearLinkList(LinkList &head) {
    LinkList p = head->next;
    LinkList q;
    while (p != head) { //p != L  p!=NULL
        q = p;
        p = p->next;
        delete q;
    }
    head->next = head; //链表为空
    return OK;
}

//取值
Status GetLinkList(LinkList head, int i, ElemType &e) {
    LinkList p = head->next;
    int j = 1;
    while (p != head && j < i) {  //p != L
        p = p->next;
        j++;
    }
    if (p == head) {//p==L
        return ERROR;
    }
    e = p->data;

    return OK;
}

//查找
int LocateLinkListElem(LinkList head, ElemType e) {
    LinkList p = head->next;
    int j = 1;
    while (p != head && (p->data != e)) {//p != L p!=NULL
        p = p->next;
        j++;
    }
    if (p == head) { //p==L  !p<=>p==NULL
        return 0;
    }
    return j;
}

//删除
Status ListDelete(LinkList &head, int i, ElemType &e) {
    LinkList p = head;
    int j = 0;
    while (p->next != head && j < i - 1) {  //p != L
        p = p->next;
        j++;
    }
    if (p->next == head) { //p==L
        return ERROR;
    }
    LinkList q = p->next;
    e = q->data;
    p->next = q->next;
    delete q;
    return OK;
}

//头插法创建循环链表
void CreateLinkList_H(LinkList &head, int n) {
    InitList(head);
    for (int i = 0; i < n; i++) {
        LNode *p = new LNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        p->next = head->next;
        head->next = p;
    }
}

//尾插法创建循环链表
void CreateLinkList_R(LinkList &head, int n) {
    InitList(head);
    LinkList r = head;
    for (int i = 0; i < n; i++) {
        LNode *p = new LNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        //p->next=NULL   p->next=head
        //p->next = r->next;
        r->next = p;
        r = p;
    }
    r->next = head;                //尾结点next域指向头结点
}

//输出链表元素
void printLinkList(LinkList head) {
    LinkList p = head->next;
    while (p != head) { //p != L
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {

    LinkList list;

    //初始化
    printf("单链表正在初始化....\n");
    int InitStatus = InitList(list);
    if (InitStatus == OK) {
        printf("单链表初始化成功！\n");
    } else {
        printf("单链表初始化失败！\n");
    }

    choice();    //调用功能菜单函数
    int temp = 1;  //通过改变temp的值来跳出while循环

    while (temp) {
        int flag;
        printf("请输入所需的功能编号：\n");
        scanf("%d", &flag);

        switch (flag) {//通过开关进行功能选择
            case 1: {//插入元素
                int insertIndex;
                ElemType inserElem;
                printf("请输入插入元素位置及插入元素(请在英文状态下输入例如:1,a): \n");
                scanf("%d,%c", &insertIndex, &inserElem);
                Status InsertS = ListInsert(list, insertIndex, inserElem);
                if (InsertS == OK) {
                    printf("向循环链表%d个位置,插入元素为%c成功！\n\n", insertIndex, inserElem);
                } else {
                    printf("向循环链表插入元素失败！\n\n");
                }
            }
                break;
            case 2: {//求单链表的长度
                int length = GetLinkListLength(list);
                printf("循环链表的长度为:%d。 \n\n", length);
            }
                break;
            case 3: {//取值
                Status GetIndex;
                printf("请输入需要查询的元素的位置：\n");
                scanf("%d", &GetIndex);
                ElemType GetElem;
                int GetStatus = GetLinkList(list, GetIndex, GetElem);
                if (GetStatus == OK) {
                    printf("从循环链表中获取第%d位置元素成功，所获取到的元素为：%c。\n\n", GetIndex, GetElem);
                } else {
                    printf("从循环链表中获取第%d位置元素失败！\n\n", GetIndex);
                }
            }
                break;
            case 4: {//查找
                ElemType LocateElem;
                printf("请输入想要查找元素：\n");
                getchar();    //用于接收回车
                scanf("%c", &LocateElem);
                Status LocateIndex = LocateLinkListElem(list, LocateElem);
                if (LocateIndex > 0) {
                    printf("从循环链表中查找元素%c成功，它在循环链表中的位置为第%d个！\n\n", LocateElem, LocateIndex);
                } else {
                    printf("从循环链表中查找元素%c失败！\n\n", LocateElem);
                }
            }
                break;
            case 5: {//删除
                Status DeleteIndex;
                printf("请输入想要删除元素的位置：\n");
                scanf("%d", &DeleteIndex);
                ElemType DeleteElem;
                ElemType DeleteStatus = ListDelete(list, DeleteIndex, DeleteElem);
                if (DeleteStatus == OK) {
                    printf("删除循环链表第%d个位置的元素成功，删除的元素为：%c。\n\n", DeleteIndex, DeleteElem);
                } else {
                    printf("删除循环链表第%d个位置的元素失败！\n\n", DeleteIndex);
                }
            }
                break;
            case 6: {//销毁
                Status DestoryStatus = DestoryLinkList(list);
                if (DestoryStatus == OK) {
                    printf("循环链表销毁成功！\n\n");
                } else {
                    printf("循环链表销毁失败！\n\n");
                }
            }
                break;
            case 7: {//清空
                Status ClearStatus = ClearLinkList(list);
                if (ClearStatus == OK) {
                    printf("循环链表清空成功！\n\n");
                } else {
                    printf("循环链表清空失败！\n\n");
                }
            }
                break;
            case 8: {//批量插入
                int on;
                printf("请输入想要插入的元素个数：\n");
                scanf("%d", &on);
                ElemType array[on];
                for (int i = 1; i <= on; i++) {
                    getchar();
                    printf("向循环链表第%d个位置插入元素为:", (i));
                    scanf("%c", &array[i]);
                }

                for (int i = 1; i <= on; i++) {
                    Status InsertStatus = ListInsert(list, i, array[i]);
                    if (InsertStatus == OK) {
                        printf("向循环链表第%d个位置插入元素%c成功！\n", i, array[i]);
                    } else {
                        printf("向循环链表第%d个位置插入元素%c失败！\n", i, array[i]);
                    }
                }
            }
                break;
            case 9: {//输出链表元素
                //temp=0;
                //return 0;
                printf("现在链表的元素为：");
                printLinkList(list);
            }
                break;
            case 10: {//头插法创建单链表
                //getchar();
                LinkList L;
                printf("请输入五个字符：\n");
                CreateLinkList_H(L, 5);
                int length = GetLinkListLength(L);
                printf("\n循环链表的长度为:%d。 \n", length);
                printf("循环链表的元素为:");
                printLinkList(L);
                printf("\n");
            }
                break;
            case 11: {//尾插法创建单链表
                LinkList L;
                printf("请输入五个字符：\n");
                CreateLinkList_R(L, 5);
                int length = GetLinkListLength(L);
                printf("\n循环链表的长度为:%d。 \n", length);
                printf("循环链表的元素为:");
                printLinkList(L);
                printf("\n");
            }
                break;
            default:
                printf("输入错误，无此功能，请检查输入:\n\n");
        }
    }

}

四、运行结果

 

 

 

 

殊迟
关注
  • 10
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
实现循环单链表的各种基本运算的算法
04-17
数据结构与算法 李春葆 第五版实验报告2.22 含代码和结果
C语言写的简单的循环单链表，便于阅读和复习。经运行，正确。
09-14
C语言写的简单的循环单链表，便于阅读和复习。经运行，正确。 C语言写的简单的循环单链表，便于阅读和复习。经运行，正确。
数据结构之循环单链表（C语言附完整代码）
m0_62795460的博客
11-09 6294
循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。示意图：声明循环单链表typedef struct LNode //定义单链表结点类型 {注意：本文章讨论的循环单链表是带头结点的循环单链表。增加头结点的优点如下：1.循环单链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。2.无论循环单链表是否为空都有一个头结点，因此统一了空表和非空表的处理过程。
循环但链表各种基本运算
ヤ冰楓ˊ﹋ろ
01-04 816
 函数：1．Initlist(sqlist *&l):初始化循环单链表l.2．Destroylist(sqlist *l):释放循环单链表l.3．Listempty(sqlist *l):判断循环单链表l是否为空表.4．Listlength(sqlist *l):返回循环单链表l的元数个数.5．Displist(sqlist *l):输出循环单链表l.6．Getelem
循环单链表的创建及插入-头插法和尾插法
小陈没烦恼
02-03 3821
什么是循环链表？ 循环链表是另一种形式的链式存储结构，它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 循环链表的操作 1.初始化 2.头插法创建链表 3.尾插法创建链表 4.打印链表中的所有元素 5.其他的操作通普通单链表相同，这里不在赘述。参考文章：单链表基本操作 初始化链表 在初始化链表这里需要注意区分与普通单链表的差别。 普通单链表初始时把头结点的下一个结点指向NULL。 循环单链表初始化时把头结点的下一个结点指向了头结点本身。 /*初始化链表*...
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2223
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
单链表中的基本操作(详细代码图解+注释+算法步骤)
Xiao_Ya__的博客
05-23 5662
单链表中的基本操作(详细代码图解+注释+算法步骤)
数据结构与算法-循环单链表操作及应用C语言实现（超详细注释/设计/实验/作业）
程序员老茶的博客
02-10 597
通过此次实验，进一步熟悉了循环链表操作的有关知识，对书本上的知识又有了更进一步的认识。另一方面，通过编写程序也让对C语言课程中学习到的有关知识进行了一次复习。由于在大一时对C语言的学习并不太好，尤其对结构体指针的理解并深，所以在编写程序的初期遇到了一些困难。为了解决问题，我又对C语言的相关章节进行了复习，在复习的过程中加深了对结构体、指针、字符数组、字符串函数、for循环、while循环、函数的理解。
单向循环链表的基本操作（头插，尾插，从任意结点处遍历整个链表）
小菜鸟的进阶
01-30 3322
单向循环链表与单链表的区别： 单向循环链表： 1.尾结点的指针域指向首结点，可以通过任意结点遍历整个链表 tail->next = head; 2.为空链表时，头结点指向自己 head->next = head; 单链表： 1.尾结点的指针域指向NULL，只可以通过头结点遍历整个链表 tail = NULL; 2.为空链表时，...
单向循环链表基本操作
icquu的博客
10-14 481
C和其他语言都一样，只是关键字更少，更接近硬件，底层操作大都需要用C中的头文件和库函数来实现。学习的过程也不乏乐趣，在入门阶段，不建议大家去磨练算法，非常枯燥。建议学习一些系统编程和网络编程，趣味性更强，也能做一些有用的东西，不会乏味到失去兴趣。等过了这个阶段，对C的认识已经比较全面和具有一定深度了，再去看一些算法相关的，也不会觉得很复杂了。后期，不管用什么语言都完全是个人思维的表达，不影响表达思...
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队...
C语言 循环单链表的简单操作
09-11
C语言 数据结构里面的，循环单链表的简单操作
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
2.3.2　单链表基本操作的实现　26 2.3.3　循环链表　31 2.3.4　双向链表　32 2.4　线性表的应用　34 2.4.1　一般线性表的合并　34 2.4.2　有序表的合并　35 2.4.3　一元多项式的表示及相加　37 2.5　小结　40 习题　...
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
头歌数据结构的题目： 顺序表的基本操作和应用 链表的基本操作和应用， 循环队列的应用 同时还有一些附加题，n皇后和钓鱼
线性表之循环链表的建立、查找、插入和删除（附C++程序）
ch18328071580的博客
07-07 3341
本文介绍了线性表中的循环链表，包括循环单链表、循环双链表的头插法和尾插法的建立，按元素查找，插入和删除操作。
实现循环单链表各种基本运算的算法
xiezhi123456的博客
01-12 1759
/** *   实现循环单链表各种基本运算的算法 * */ #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct LNode {     ElemType data;//数据域     struct LNode *nex...
详解循环链表（数据结构C语言）
最新发布
m0_59068067的博客
10-15 1007
本文简单介绍了循环链表的基本概念，特点以及基础运算，并附上了代码以及结果，希望以后复习时可以加深自己的印象；在运行过程中，总有一些卡壳的部分，在朋友的指导下，修改代码并顺利完成结果。
循环单链表基本运算算法
喜欢藏风里
04-07 836
#include <stdio.h> #include <malloc.h> typedef int ElemType; typedef struct LNode //定义单链表结点类型 { ElemType data; struct LNode *next; } LinkNode; void CreateListF(LinkNode *&L,Elem...
循环链表(单向+双向)及典型应用场景
cj1561435010的博客
02-23 5302
一、单向循环链表 1、单向循环链表明细        单向循环链表其实就是尾结点有指向头结点的指针，一般链表尾结点指向的都是空。        添加结点的时候尾部情况和普通情况一样，不需要特殊处理(因为尾部有指向头结点的指针)。头部添加结点的时候还需要对第一次...
单链表操作实现getelem_【数据结构】单链表的基本操作（C语言
06-06
好的，以下是单链表操作实现getelem的C语言代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义单链表结构体 typedef struct node { int data; struct node* next; } Node; // 创建单链表 Node* createList(int arr[], int n) { Node* head = NULL; Node* tail = NULL; for (int i = 0; i < n; i++) { Node* node = (Node*)malloc(sizeof(Node)); node->data = arr[i]; node->next = NULL; if (head == NULL) { head = node; tail = node; } else { tail->next = node; tail = node; } } return head; } // 获取单链表指定位置的元素值 int getElem(Node* head, int position) { int i = 0; Node* curr = head; while (curr != NULL && i < position) { curr = curr->next; i++; } if (curr == NULL) { printf("Error: position out of range.\n"); return -1; } else { return curr->data; } } int main() { int arr[] = {1, 2, 3, 4, 5}; int n = sizeof(arr) / sizeof(arr[0]); Node* head = createList(arr, n); printf("The list: "); Node* curr = head; while (curr != NULL) { printf("%d ", curr->data); curr = curr->next; } printf("\n"); printf("The element at position 2 is %d.\n", getElem(head, 2)); printf("The element at position 5 is %d.\n", getElem(head, 5)); return 0; } ``` 输出结果为： ``` The list: 1 2 3 4 5 The element at position 2 is 3. Error: position out of range. The element at position 5 is -1. ``` 以上代码实现了单链表的基本操作之一：获取指定位置的元素值。在 `getElem` 函数中，我们使用了一个循环遍历链表，依次访问每个节点，直到找到目标位置对应的节点，然后返回该节点的数据值。如果目标位置超出了链表的范围，我们输出错误信息并返回 -1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

殊迟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值