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

最新推荐文章于 2024-02-21 19:25:12 发布
最新推荐文章于 2024-02-21 19:25:12 发布
阅读量990 收藏 25
点赞数 12
文章标签： 数据结构 c语言 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56814370/article/details/135734041
版权
本文详细介绍了循环单链表的定义、优缺点，以及在C语言中实现的循环单链表的各种基本操作，包括插入、删除、查找、初始化、销毁等，并提供了头插法和尾插法创建循环链表的示例。
摘要由CSDN通过智能技术生成

目录

一、循环单链表

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");
        }
    }

}

四、运行结果

 

 

 

 

殊迟
关注
  • 12
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【数据结构】循环单链表的实现（C语言）
( :3 )
09-29 3688
 循环单链表应掌握以下基本操作： 1、建立一个空的循环单链表。 2、获得循环单链表的最后一个结点的位置。 3、输出循环单链表中各结点的值。 4、在循环单链表中查找值为x的结点。 5、在循环单链表中第i个结点后插入值为x的新结点。 6、在循环单链表中删除值为x 的结点。 以下是头文件：（可以有选择的看，有很多算法） #ifndef CIRCLE_HEAD_LINK_H_INCLUD...
循环链表(单向+双向)及典型应用场景
cj1561435010的博客
02-23 5408
一、单向循环链表 1、单向循环链表明细        单向循环链表其实就是尾结点有指向头结点的指针，一般链表尾结点指向的都是空。        添加结点的时候尾部情况和普通情况一样，不需要特殊处理(因为尾部有指向头结点的指针)。头部添加结点的时候还需要对第一次...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3123
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
单向链表、单向循环链表的基本操作
weixin_52545652的博客
04-15 242
单向链表的基本操作
【数据结构与算法】- (带尾指针)单循环链表 - 详细实现步骤及代码(C/C++)
wkd_007的博客
03-30 6967
本文主要介绍带尾指针的单循环链表，以及详细的实现步骤讲解，最后提供一份自己实现带尾指针的单循环链表的C语言代码
数据结构---单向循环链表的基本操作
最新发布
weixin_51949422的博客
02-21 385
【代码】数据结构---单向循环链表的基本操作。
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
《数据结构》（C语言版）教程
10-14
《数据结构》（C语言版）教程是一门深入学习计算机科学与技术不可或缺的重要课程，它主要探讨如何在计算机中组织和存储数据，以便高效地访问和处理这些数据。本教程结合了C语言这一强大而灵活的编程语言，使得学生...
C语言数据结构单链表的增删改查
05-27
以上就是C语言中实现单链表的基本操作。理解这些操作对于学习更复杂的数据结构如双向链表、循环链表以及树等都至关重要。在实际应用中，我们还需要考虑错误处理、内存管理和效率优化等问题，比如使用尾插法提高插入...
数据结构-单链表删除绝对值相同的元素-c语言代码
11-07
在本文中，我们将深入探讨如何使用C语言实现一个数据结构操作——删除单链表中绝对值相同的元素。首先，我们要了解单链表的基本概念。单链表是一种线性数据结构，其中每个节点包含一个数据域和一个指向下一个节点的...
数据结构 单链表的生成算法 c语言实现
06-21
在计算机科学中，数据结构...通过这些基本操作，我们可以构建出各种复杂的数据结构和算法，解决实际问题。单链表的生成和操作是理解和掌握数据结构的基础，也是进一步学习高级数据结构如双向链表、哈希表、树等的前提。
【数据结构】【王道】【线性表】循环链表的实现及基本操作（可直接运行）
treesorshining的博客
07-12 506
总目录 由于循环链表尾部并未指向空，而是指向头指针。循环单链表尾结点指针域指向头结点；循环双链表尾结点后继指针指向头结点，头结点前驱指针指向尾节点。故而各类基本操作与之前单链表、双链表基本操作相差不大，主要就是在于对尾结点的处理问题，之前非循环链表尾结点指向空，如果要执行插入、删除等可能需要对后继结点取指针域的操作会导致报错，而循环链表就没有这个问题，因为它尾结点并非指向空。综上，在此处不会给出全部的基本操作，仅给出简单插入和删除作为示例，可与博主之前实现单链表、双链表的文章参照查看，改动主要是对于尾结点的
纯C语言完整代码操作单链表(初始化、插入、删除、查找...)
qq_44697268的博客
08-26 1093
C语言操作单链表
单链表及循环单链表的建立、查找、插入、删除
xiahuayong的博客
04-03 4175
2.1单链表的建立 1.建立一个带头结点的单链表：L={12,13,21,24}。数据元素的值由键盘输入。 2.实验要点及说明 单链表的建立有头插入法和尾插入法。本实验以尾插法为例建立单链表。单链表的结点结构除了数据域外，只含有一个指针域。注意：头结点的建立方法，新元素的插入的位置及指针的变化。单链表的建立示意图： #include <stdio.h> #include <conio.h> #include <stdlib.h> #define OK 1 #define
【数据结构|单循环链表】单循环链表大部分基本操作总结（严蔚敏数据结构）
爱喝冰红茶的方舟的博客
04-27 1307
本文基本涵盖了单循环链表的大部分基本操作，与严蔚敏数据结构内容大致贴合，且大部分函数取名结合STL，可结合来学习，可直接最后跳转完整代码复制，代码运行没问题（截图省了）有问题欢迎交流。
循环单链表的基本操作
罗小黑の窝
04-30 766
循环单链表所尊崇的结点如图 所实现的功能如下： void InitList(List *list);//初始化 bool push_back(List *list, ElemType x);//尾插 bool push_front(List *list, ElemType x);//头插 bool pop_back(List *list);//尾删 bool pop_front
单向循环链表基本操作
weixin_65259109的博客
01-07 172
2、单向循环链表的尾结点指向头结点（虽然是一个环状结构，但是仍然有头结点、首结点、尾结点）1、单向循环链表可以从任一位置开始访问全部结点。其他的操作与单链表相同。
循环单链表（C语言实现）
Mr_John
10-26 519
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int DataType; typedef struct Node { DataType data; // 数据域 struct Node * next; // 指针域 }LinkList; LinkList* Init_List(); // ...
单向循环链表代码c语言
03-26
struct ListNode { int val; struct ListNode *next; }; typedef struct ListNode ListNode; ListNode* createListNode(int val) { ListNode* node = (ListNode*)malloc(sizeof(ListNode)); node->val = val; node->next = NULL; return node; } ListNode* createLinkedList(int arr[], int n) { if (n <= 0) { return NULL; } ListNode* head = createListNode(arr[0]); ListNode *p = head; for (int i = 1; i < n; i++) { p->next = createListNode(arr[i]); p = p->next; } p->next = head; return head; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殊迟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值