二、《循环链表》

已于 2023-10-18 20:28:01 修改
阅读量89 收藏
点赞数
文章标签： 链表 数据结构
于 2023-10-14 19:30:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61786342/article/details/133828380
版权

目录

一、循序链表简介

循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

2、循环链表特点

二、循环链表的运算

三、循环链表的实现

1.简单链表的定义

2、初始化

3、插入元素

4、删除元素

5、查找元素x,并指定位置

6、求链表长度

7、输出链表

四、完整代码

1、main.c

2.SingleLinkList.c

3.SingleLinKList.h

4.welcome.h

6、参考文献

一、循序链表简介

根据前面的线性表，来完成循环链表，预知了解线性表知识，请前往CSDN此处；

1、循环链表的定义

循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

循环链表的逻辑关系图如下：

50afd45db17e45fbb7c4ee34d86c4740.jpeg
标题

2、循环链表特点

  • 无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活。
     

二、循环链表的运算

  • 插入节点：在循环链表中插入一个新的节点需要找到插入位置，修改相关节点的指针使其形成环。插入位置可以通过遍历找到，也可以通过一些技巧（如双指针法）快速找到。
  • 删除节点：要删除一个节点，需要找到该节点并修改相关节点的指针使其形成环。要删除的节点可能是头节点或尾节点，也可能是链表中的任意节点。删除节点时需要处理多种情况。
  • 遍历链表：由于循环链表的最后一个节点的指针指向第一个节点，因此可以从任意节点开始遍历整个链表。遍历时需要注意不要形成死循环。
  • 查找元素：可以通过遍历循环链表来查找指定元素，也可以使用哈希表等数据结构来加速查找。

三、循环链表的实现

1.简单链表的定义

/*简单链表的定义*/
typedef struct node
{
    DataType        data;    /*数据域*/
    struct node        *next;    /*指针域*/
}SingleLinkList, SingleLinkNode;

2、初始化

/*1. 初始化*/
int init(SingleLinkList **Head)
{
    if(1)
    {
        /*申请内存*/
        (*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
        /*判断内存申请是否成功*/
        if(*Head == NULL)
        {
            printf("申请内存错误， 初始化失败！[100001]\n");
            return 100001;
        }
        (*Head)->next = *Head;
        /*循环链表*/
        /*
            (*Head)->next = *Head;
        */
        return 0;
    }
    else
    {
        printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
        return 100002;
    }
}

3、插入元素

/*3. 插入元素,头插法*/

int insert_head(SingleLinkList **Head, DataType x)
{
    SingleLinkNode *newNode;

    if(0)
    {
        printf("链表未初始化！[100003]\n");
        return 100003;
    }
    
    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    if(!newNode)
    {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }
    newNode->data = x;
    newNode->next = *Head;

    (*Head)->next = newNode;

    return 0;
}
 

/*3. 插入元素， 尾插法*/

int insert_tail(SingleLinkList **Head, DataType x)

{
    SingleLinkNode *newNode;
    SingleLinkNode *p;

    if(0)
    {
        printf("链表未初始化！[100003]\n");
        return 100003;
    }
    
    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    if(!newNode)
    {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }

    newNode->data = x;
    newNode->next = *Head;
    /*
      循环链表
      newNode->next = *Head;
    */

    p = (*Head);/**/

    while(p->next!=*Head)
    {
        p = p->next;/*p指向原来的下一个节点*/
    }

    p->next = newNode;/*p指向头节点*/

    return 0;
}

/*3. 插入元素，在位置i处插入元素x */

int insert(SingleLinkList **Head, int i, DataType x)
{
    int j;
    SingleLinkNode *p;
    SingleLinkNode *newNode;

    
    /*对i进行判断，0<i<=length+1*/
    if(i<1 || i>length(*Head)+1)
    {
        printf("位置i不是链表有效位置！[100005]\n");
        return 100005;
    }
    p = (*Head);
    j = 1;

    while(j<i)
    {
        j++;
        p = p->next;
    }

    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    /*此处省略检测newNode是否申请成功*/

    newNode->data = x;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}
 

4、删除元素

/*3. 删除元素, 删除值为x的元素*/

int delete(SingleLinkList **Head, DataType x)
{
    int i;
    int j;

    SingleLinkNode *p;
    SingleLinkNode *q; /*要删除的元素x*/

    i = find(*Head,x);
    if(!i)
    {
        printf("元素x【%d】不存在！100006\n", x);
        return 100006;
    }
    
    p = (*Head);
    j=1;

    while(j<i)
    {
        j++;
        p = p->next;
    }
    
    q = p->next;
    p->next = q->next;

    free(q); /*释放内存*/

    return 0;
}
 

5、查找元素x,并指定位置

/*5. 查找值为x的元素，返回位置i */

int find(SingleLinkList *Head, DataType x)
{
    int i;
    SingleLinkNode *p;

    i = 1;
    p = Head->next;

    while( p!= Head && p->data != x)  /*while( p!= Head && p->data != x) */
    {
        i++;
        p = p->next;
    }

    if(p==Head)  /* if(p->next == Head) */
    {
        return 0;
    }
    else
    {
        return i;
    }

}

6、求链表长度

/*6. 求链表的长度 */

int length(SingleLinkList *Head)
{
    int len=0;
    SingleLinkNode *p;

    p = Head->next;
    while(p!=Head)    /* while(p!=Head) */
    {
        len++;
        p = p->next;
    }
    return len;
}
 

7、输出链表

void print(SingleLinkList *Head)
{
    SingleLinkNode *p;
    int i=0;

    p = Head->next;
    if(p==Head)             /*  if(p!=Head)  */
    {
        printf("链表为空！\n");
        return;
    }
    while(p!=Head)  /* while(p!=Head)  */
    {
        printf("Node[%d]. = %d\n", ++i, p->data);
        p = p->next;
    }
}

四、完整代码

1、main.c

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.h"
#include "welcome.h"


int main(int argc, char* argv[])
{
    SingleLinkList *Head;
    DataType x;
    int i,m,n,cmd;

    for(i=0;i<strlen(welcome);i++)
    {
        printf("%c",welcome[i]);
        for(m=0;m<1000;m++)
            for(n=0;n<1000;n++)
            {
                ;
            }
    }

    printf("-----------简单链表演示程序----------\n");
    do
    {
        printf("1. 初始化链表表\n");
        printf("2. 插入元素（头插法）\n");
        printf("3. 插入元素（尾插法）\n");
        printf("4. 插入元素（在位置i插入）\n");
        printf("5. 查找元素x\n");
        printf("6. 求链表长度\n");
        printf("7. 输出链表\n");
        printf("8. 删除元素\n");
        printf("9. 帮助\n"); 
        printf("0. 退出\n");
        printf("请输入您要进行的操作（1~9,0退出）：");
        scanf("%d", &cmd);
        switch(cmd)
        {
        case 1:
            if(!init(&Head))
            {
                printf("链表已初始化！\n");
            }
            break;
        case 2:
            printf("请输入插入元素x：x=");
            scanf("%d",&x);
            if(!insert_head(&Head,x))
            {
                printf("元素（%d）已插入\n", x);
            }
            break;
        case 3:
            printf("请输入插入元素x：x=");
            scanf("%d",&x);
            if(!insert_tail(&Head,x))
            {
                printf("元素（%d）已插入\n", x);
            }
            break;
        case 4:
            printf("请输入插入元素位置i和元素x（i，x）：");
            scanf("%d,%d", &i, &x);
            if(!insert(&Head, i, x))
            {
                printf("已在位置（%d）插入元素（%d）！\n",i, x);
            }
            break;
        case 5:
            printf("请输入要查找的元素x：");
            scanf("%d", &x);
            if(i = find(Head,x))
            {
                printf("元素%d存在，在链表位置%d.\n", x, i);
            }
            else
            {
                printf("在链表中未找到元素x。\n");
            }
            break;
        case 6:
            printf("链表的长度为：%d\n", length(Head));
            break;
        case 7:
            print(Head);
            break;
        case 8:
            printf("请输入要删除的元素x：");
            scanf("%d", &x);
            if(!delete(&Head, x))
            {
                printf("元素x【%d】已删除!\n", x);
            }
            break;
        case 10:
            printf(" 本程序为链表的演示程序，由林振发设计开发，程序完成了链表的删除，添加，查询等功能！！！！！\n");
            break;
            
        }
    }while(cmd != 0);

    return 0;
}

2.SingleLinkList.c

/*
    SingleLinkList.c
    
*/
#include "SingleLinkList.h"
#include <stdlib.h>
#include <stdio.h>

/*1. 初始化*/
int init(SingleLinkList **Head)
{
    if(1)
    {
        /*申请内存*/
        (*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
        /*判断内存申请是否成功*/
        if(*Head == NULL)
        {
            printf("申请内存错误， 初始化失败！[100001]\n");
            return 100001;
        }
        (*Head)->next = *Head;
        /*循环链表*/
        /*
            (*Head)->next = *Head;
        */
        return 0;
    }
    else
    {
        printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
        return 100002;
    }
}


/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
    SingleLinkNode *newNode;

    if(0)
    {
        printf("链表未初始化！[100003]\n");
        return 100003;
    }
    
    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    if(!newNode)
    {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }
    newNode->data = x;
    newNode->next = *Head;

    (*Head)->next = newNode;

    return 0;
}


/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
    SingleLinkNode *newNode;
    SingleLinkNode *p;

    if(0)
    {
        printf("链表未初始化！[100003]\n");
        return 100003;
    }
    
    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    if(!newNode)
    {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }

    newNode->data = x;
    newNode->next = *Head;
    /*
      循环链表
      newNode->next = *Head;
    */

    p = (*Head);/**/

    while(p->next!=*Head)
    {
        p = p->next;/*p指向原来的下一个节点*/
    }

    p->next = newNode;/*p指向头节点*/

    return 0;
}


/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
    int j;
    SingleLinkNode *p;
    SingleLinkNode *newNode;

    
    /*对i进行判断，0<i<=length+1*/
    if(i<1 || i>length(*Head)+1)
    {
        printf("位置i不是链表有效位置！[100005]\n");
        return 100005;
    }
    p = (*Head);
    j = 1;

    while(j<i)
    {
        j++;
        p = p->next;
    }

    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    /*此处省略检测newNode是否申请成功*/

    newNode->data = x;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}


/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
    int i;
    int j;

    SingleLinkNode *p;
    SingleLinkNode *q; /*要删除的元素x*/

    i = find(*Head,x);
    if(!i)
    {
        printf("元素x【%d】不存在！100006\n", x);
        return 100006;
    }
    
    p = (*Head);
    j=1;

    while(j<i)
    {
        j++;
        p = p->next;
    }
    
    q = p->next;
    p->next = q->next;

    free(q); /*释放内存*/

    return 0;
}


/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
    int i;
    SingleLinkNode *p;

    i = 1;
    p = Head->next;

    while( p!= Head && p->data != x)  /*while( p!= Head && p->data != x) */
    {
        i++;
        p = p->next;
    }

    if(p==Head)  /* if(p->next == Head) */
    {
        return 0;
    }
    else
    {
        return i;
    }

}

/*4. 链表长度*/
int length(SingleLinkList *Head)
{
    int len=0;
    SingleLinkNode *p;

    p = Head->next;
    while(p!=Head)    /* while(p!=Head) */
    {
        len++;
        p = p->next;
    }
    return len;
}

/*6.输出链表*/
void print(SingleLinkList *Head)
{
    SingleLinkNode *p;
    int i=0;

    p = Head->next;
    if(p==Head)             /*  if(p!=Head)  */
    {
        printf("链表为空！\n");
        return;
    }
    while(p!=Head)  /* while(p!=Head)  */
    {
        printf("Node[%d]. = %d\n", ++i, p->data);
        p = p->next;
    }
}

3.SingleLinKList.h

/*
    SingleLinkList.h
*/

typedef int DataType;

/*简单链表的定义*/
typedef struct node
{
    DataType        data;    /*数据域*/
    struct node        *next;    /*指针域*/
}SingleLinkList, SingleLinkNode;


/*1. 初始化*/
int init(SingleLinkList **Head);

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x);

/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x);

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x);

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x);

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x);

/*6. 求链表的长度 */
int length(SingleLinkList *Head);

/*7.输出链表*/
void print(SingleLinkList *Head);

4.welcome.h

 char welcome[]=(
    "         lovelove                   lovelove\n"
    "       lovelovelove               lovelovelove\n"
    "     lovelovelovelove           lovelovelovelove\n"
    "   lovelovelovelovelove       lovelovelovelovelove\n"
    "  lovelovelovelovelovelo     lovelovelovelovelovele\n"
    " lovelovelovelovelovelovelolovelovelovelovelovelovee\n"
    "  lovelovelovelovelovelolovellovelovelovelovelovele\n"
    "   lovelovelovelovelovelovelolovelovelovelovelove\n"
    "     lovelovelovelovelovelovelovloveloveloveloe\n"
    "       lovelovelovelovelovelovelovloveloveloe\n"
    "         lovelovelovelovelolovelovelloveloe\n"
    "           lovelovelovelovelovelovelovele\n"
    "             lovelovelovelovelovelocele\n"
    "               lovelovelovelovelovele\n"
    "                 lovelovelovelovele\n"
    "                   loveloveloveve\n"
    "                     lovelovelo\n"
    "                       lovelov\n"
    "                         love\n"
    "                          爱\n"

    );
 

五、运行结果截图

12ed5e1e797f4b5db438a05bec5a0bd1.png027238f3f7254a66a61e2b2a1f66f377.png

六、总结

循环链表是一种特殊的数据结构，它由一组节点组成，每个节点包含一个指向下一个节点的指针，最后一个节点的指针指向第一个节点，形成一个环。循环链表可以用来解决一些需要从链表任意节点开始遍历整个链表的问题。

  • 循环链表的特点是最后一个节点的指针不是空（NULL），而是指向第一个节点，从而形成了一个环。
  • 循环链表的运算主要包括插入节点、删除节点、遍历链表、查找元素和修改节点值等操作。
  • 插入节点和删除节点需要修改相关节点的指针，使其形成环；遍历链表可以从任意节点开始，但要注意避免形成死循环；查找元素可以通过遍历循环链表来实现，也可以使用其他数据结构来加速查找。
  1. 在实际应用中，可以根据具体需求选择是否使用循环链表。如果需要从链表任意节点开始遍历整个链表，则可以考虑使用循环链表。
  2. 循环链表相对于普通链表来说比较复杂，需要注意各种情况的处理。

七、参考文献

  1. 数据结构c语言版本（李刚）
  2. 百度查询
  3. csdn博客

一万里晴空60
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单向循环链表
01-20
循环链表 循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点...
C语言实现循环链表
12-17
本文实例为大家分享了C语言实现循环链表的具体代码，供大家参考，具体内容如下 注意事项： 1、循环链表设置尾指针。由于在链表的操作过程中，尾指针会不断变化，所以在一些函数的形参中都设置指向头指针的指针。以及...
双向循环链表
10-13
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点...一般我们都构造双向循环链表。
C++实现双向循环链表
12-20
本文实例为大家分享了C++实现双向循环链表的具体代码，供大家参考，具体内容如下 一、概念 1.在双链表中的每个结点应有两个链接指针：  lLink -> 指向前驱结点 （前驱指针或者左链指针） rLink->指向后继结点...
数据结构——哈希表
qq_61350148的博客
06-08 826
使用java语言实现《数据结构——哈希表》。
数据结构 -＞反转链表
最新发布
2401_83373946的博客
06-12 222
这个函数使用迭代的方法反转了一个单向链表。通过逐个节点的处理，将每个节点的next指针反转，最终得到反转后的链表。
【数据结构】单链表（C语言）
2402_82689232的博客
06-12 952
本篇文章介绍的单链表的基础概念及结构实现
【数据结构】双链表
weixin_73483158的博客
06-11 465
带头双向循环链表。
从零开始学数据结构系列之第三章《二叉树链式结构及实现2》
铁匠匠匠的博客
06-09 1013
​   根遍历的原理就是，​   一句话来讲，就是。所以我们按如上顺序来算的话。
ACM算法学习路线、清单
qq_45477639的博客
06-10 1782
算法与数据结构学习路线
宝藏速成秘籍（7）堆排序法
m0_73399576的博客
06-10 875
堆排序法速成秘籍
数据结构（DS）学习笔记（二）：数据类型与抽象数据类型
她与剑意皆失的博客
06-11 721
数据类型就是一组性质相同的值的集合以及定义于这个值集合上的一组操作的总称。数据类型=值的集合+值集合上的一组操作C语言中基本数据类型：整型：int 长整型：long int 短整型：short int 浮点型（单精度）：float 浮点型（双精度）：double 字符型：char 布尔型：bool不同类型的变量，其所能取的值的范围不同，所能进行的操作不同。例如：bool类型的值为：true、false。可进行的操作：与、或、非...作用：约束变量或常量的取值范围；约束
数据结构-哈希表
passworddddddd的博客
06-11 403
他的结构就是数组，但是他神奇的地方在于对下标值的一种变换，这种变换可以称之为哈希函数，通过哈希函数可以获取到HashCode。哈希表不像数组、链表和树一样，直接画出来就知道他的结构，甚至原理。哈希表通常是基于数组进行实现的，但是对于数组，它有很多优势。
数据结构及研究
m0_63649789的博客
06-08 502
相对地，数据的物理结构则关注这些逻辑关系如何在计算机内存中实际表示，常见的有顺序存储和链式存储等方式Θic-1ΘΘic-2ΘΘic-3ΘΘic-5Θ。- **封装与抽象**：抽象数据类型通过抽象类或接口的形式定义了数据结构和可在其上执行的操作集，而不具体说明这些操作如何实现，从而实现数据类型的封装和抽象Θic-5Θ。**数据结构是计算机存储、组织数据的方式，它是相互之间存在一种或多种特定关系的数据元素的集合**Θic-1ΘΘic-2ΘΘic-3ΘΘic-4ΘΘic-5Θ。4. **算法与数据结构的关系**
数据结构---外部排序
code袁的博客
06-11 674
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构--递归和数组
code袁的博客
06-09 1014
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896递归是一种解决问题的方法，它通过将问题分解为更小的子问题来解决。在递归过程中，函数会调用自身来处理这些子问题，直到达到最简单的情况（基本情况），然后逐层返回结果，最终解决原始问题。数组是一种数据结构，用于存储相同类型的数据元素。数组中的元素通过索引访问，索引通常从0开始。数组在内存中是连续存储的，可以快速访问任何位置的元素。
数据结构--二叉树
qq_74411357的博客
06-11 1867
本篇博客将讲述二叉树这个神奇的数据结构，领略其中的逻辑和思维，并学会加以运用！
二叉树的实现（初阶数据结构）
Aa_159147的博客
06-08 1312
一棵二叉树是结点的一个有限集合，该集合：1.或者为空2.由一个根结点加上两棵别称为左子树和右子树的二叉树组成从上图可以看出：1.二叉树不存在度大于2的结点2.二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。
R语言统计分析——数据集概念和数据结构
maizeman126的博客
06-10 734
请保证指定的水平与数据中的真实值相匹配，因为任何在数据中出现而未在参数中列举的数据都将设为缺失值。factor()函数以一个整数向量的形式存储类别值，整数的取值范围是[1,...,k]（其中k是名义变量中唯一值的个数），同时一个有字符串（原始值）组成的内部向量将映射到这些整数上。这里a是数值型向量，b是字符型向量，c是逻辑型向量。由于不同的列可以包含不同模式（数值型、字符型等）的数据，数据框的概念较矩阵来说更为一般。X[i,]指矩阵中的第i行，X[,j]指矩阵中的第j列，X[i,j]指第i行第j列的元素。
C++STL链表循环链表
08-24
然而，你可以使用C语言来实现链表和循环链表。 在C语言中，你可以通过定义一个结构体来表示链表的节点，每个节点包含一个数据元素和一个指向下一个节点的指针。下面是一个简单的例子： ```c struct ListNode { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值