【数据结构】【王道】【线性表】循环链表的实现及基本操作（可直接运行）

原创 已于 2022-07-21 09:58:50 修改 · 599 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

于 2022-07-12 11:49:12 首次发布
本文详细介绍了循环单链表和循环双链表的实现，包括结构体定义、初始化、判断空、判断表尾结点、结点插入与删除等基本操作。循环链表的特点在于尾结点指向头结点，简化了某些操作，如删除最后一个结点。提供了完整的C语言代码示例，并附带了运行截图。

总目录

文章目录

1.说明

由于循环链表尾部并未指向空，而是指向头指针。循环单链表尾结点指针域指向头结点；循环双链表尾结点后继指针指向头结点，头结点前驱指针指向尾节点。故而各类基本操作与之前单链表、双链表基本操作相差不大，主要就是在于对尾结点的处理问题，之前非循环链表尾结点指向空，如果要执行插入、删除等可能需要对后继结点取指针域的操作会导致报错，而循环链表就没有这个问题，因为它尾结点并非指向空。综上，在此处不会给出全部的基本操作，仅给出简单插入和删除作为示例，可与博主之前实现单链表、双链表的文章参照查看，改动主要是对于尾结点的处理，其余操作可参照之前文章。

单链表实现：单链表的实现及基本操作（带头结点）（可直接运行）
双链表实现：双链表的实现及基本操作（可直接运行）

2.循环单链表

2.1 基本操作

2.1.1 结构体定义

typedef struct LNode {
    int data;   // 数据域
    struct LNode *next; // 指针域
} LNode, *LinkList;

2.1.2 初始化

// 初始化
bool InitList(LinkList &L) {
    // 申请分配空间
    L = (LNode*)malloc(sizeof(LNode));
    // 分配空间失败的情况
    if(L == NULL) {
        return false;
    }
    // 头结点后继指针指向头结点本身
    L->next = L;
    return true;
}

2.1.3 判空

// 判断循环单链表是否为空
bool Empty(LinkList L) {
    // 判断头结点指针域是否指向头结点本身即可
    if(L->next == L) {
        return true;
    } else {
        return false;
    }
}

2.1.4 判断是否是表尾结点

// 判断结点p是否是表尾结点
bool isTail(LinkList L, LNode *p) {
    // 如果p结点指针域指向头结点，那么就是表尾结点（循环链表特性）
    if(p->next == L) {
        return true;
    } else {
        return false;
    }
}

2.1.5 结点后插入

// 指定结点后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p, int e) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 此处先将要插入结点的指针域指向前一个结点的指针域，即后一个结点的地址
    // 之后再令前一个结点的指针域指向要插入结点
    // 顺序不可颠倒，否则可能出现找不到之后结点的情况
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

2.1.6 删除指定节点

// 删除指定节点
bool DeleteNode(LNode *p) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    // 此操作可以理解为将p节点与其后继结点进行数据域交换
    // 之后再删除其后继结点，可以视作完成了删除，且避免了寻找前驱结点的遍历操作
    // 由于是循环单链表，所以在尾部时无需对最后一个结点进行特殊处理
    // 因为循环单链表最后一个结点的后继指针指向头结点
    // 所以即使p是最后一个结点也可以处理
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}

2.1.7 输出所有元素

// 输出所有链表元素
void PrintList(LinkList L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    LNode* p = L->next;
    while(p != NULL && p != L) {
        printf("%d  ", p->data);
        if(p->next == L) {
            break;
        }
        p = p->next;
    }
    printf("\n");
}

2.2 完整代码

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

typedef struct LNode {
    int data;   // 数据域
    struct LNode *next; // 指针域
} LNode, *LinkList;

// 初始化
bool InitList(LinkList &L) {
    // 申请分配空间
    L = (LNode*)malloc(sizeof(LNode));
    // 分配空间失败的情况
    if(L == NULL) {
        return false;
    }
    // 头结点后继指针指向头结点本身
    L->next = L;
    return true;
}

// 判断循环单链表是否为空
bool Empty(LinkList L) {
    // 判断头结点指针域是否指向头结点本身即可
    if(L->next == L) {
        return true;
    } else {
        return false;
    }
}

// 判断结点p是否是表尾结点
bool isTail(LinkList L, LNode *p) {
    // 如果p结点指针域指向头结点，那么就是表尾结点（循环链表特性）
    if(p->next == L) {
        return true;
    } else {
        return false;
    }
}

// 指定结点后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p, int e) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 此处先将要插入结点的指针域指向前一个结点的指针域，即后一个结点的地址
    // 之后再令前一个结点的指针域指向要插入结点
    // 顺序不可颠倒，否则可能出现找不到之后结点的情况
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 删除指定节点
bool DeleteNode(LNode *p) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    // 此操作可以理解为将p节点与其后继结点进行数据域交换
    // 之后再删除其后继结点，可以视作完成了删除，且避免了寻找前驱结点的遍历操作
    // 由于是循环单链表，所以在尾部时无需对最后一个结点进行特殊处理
    // 因为循环单链表最后一个结点的后继指针指向头结点
    // 所以即使p是最后一个结点也可以处理
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}

// 输出所有链表元素
void PrintList(LinkList L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    LNode* p = L->next;
    while(p != NULL && p != L) {
        printf("%d  ", p->data);
        if(p->next == L) {
            break;
        }
        p = p->next;
    }
    printf("\n");
}

int main() {
    LinkList L;
    InitList(L);
    PrintList(L);
    InsertNextNode(L, 5);
    InsertNextNode(L, 3);
    InsertNextNode(L, 1);
    PrintList(L);
    DeleteNode(L->next->next);
    PrintList(L);
}

2.3 运行截图

在这里插入图片描述

3.循环双链表

3.1 基本操作

3.1.1 结构体定义

typedef struct DNode {
    int data;   // 数据域
    struct DNode *prior, *next; // 指针域
} DNode, *DLinkList;

3.1.2 初始化

// 初始化
bool InitDLinkList(DLinkList &L) {
    // 申请分配空间
    L = (DNode*)malloc(sizeof(DNode));
    // 分配空间失败的情况
    if(L == NULL) {
        return false;
    }
    // 头结点前驱指针与后继指针都指向头结点本身
    L->prior = L;
    L->next = L;
    return true;
}

3.1.3 判空

// 判空
bool Empty(DLinkList L) {
    // 判断头结点后继指针是否指向头结点本身即可
    if(L->next == L) {
        return true;
    } else {
        return false;
    }
}

3.1.4 判断是否是表尾结点

// 判断结点p是否是表尾结点
bool isTail(DLinkList L, DNode *p) {
    // 如果p结点指针域指向头结点，那么就是表尾结点（循环链表特性）
    if(p->next == L) {
        return true;
    } else {
        return false;
    }
}

3.1.5 结点后插入

// 双链表插入
// 在p结点后插入s结点
bool InsertNextDNode(DNode *p, DNode *s) {
    // 无效输入
    if(p == NULL || s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->next = p->next;
    // 由于是循环双链表，所以在尾部时无需对最后一个结点进行特殊处理
    // 因为循环双链表最后一个结点的后继指针指向头结点，且头结点前驱指针指向尾节点
    p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}

3.1.6 结点后删除

// 删除p结点的后继结点
bool DeleteNextDNode(DNode *p) {
    // 无效输入
    if(p == NULL) {
        return false;
    }
    // 找到p的后继结点q
    DNode *q = p->next;
    // 由于是循环双链表，所以在尾部时无需对最后一个结点进行特殊处理
    // 因为循环双链表最后一个结点的后继指针指向头结点，且头结点前驱指针指向尾节点
    // 用前驱结点的后继指针指向后继结点
    p->next = q->next;
    // 用q后继结点的前驱指针指向前驱结点
    q->next->prior = p;
    // 不要忘记释放空间！！！
    free(q);
    return true;
}

3.1.7 输出所有元素

// 输出所有链表元素
void PrintList(DLinkList L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    DNode* p = L->next;
    while(p != NULL && p != L) {
        printf("%d  ", p->data);
        if(p->next == L) {
            break;
        }
        p = p->next;
    }
    printf("\n");
}

3.2 完整代码

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

typedef struct DNode {
    int data;   // 数据域
    struct DNode *prior, *next; // 指针域
} DNode, *DLinkList;

// 初始化
bool InitDLinkList(DLinkList &L) {
    // 申请分配空间
    L = (DNode*)malloc(sizeof(DNode));
    // 分配空间失败的情况
    if(L == NULL) {
        return false;
    }
    // 头结点前驱指针与后继指针都指向头结点本身
    L->prior = L;
    L->next = L;
    return true;
}

// 判空
bool Empty(DLinkList L) {
    // 判断头结点后继指针是否指向头结点本身即可
    if(L->next == L) {
        return true;
    } else {
        return false;
    }
}

// 判断结点p是否是表尾结点
bool isTail(DLinkList L, DNode *p) {
    // 如果p结点指针域指向头结点，那么就是表尾结点（循环链表特性）
    if(p->next == L) {
        return true;
    } else {
        return false;
    }
}

// 双链表插入
// 在p结点后插入s结点
bool InsertNextDNode(DNode *p, DNode *s) {
    // 无效输入
    if(p == NULL || s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->next = p->next;
    // 由于是循环双链表，所以在尾部时无需对最后一个结点进行特殊处理
    // 因为循环双链表最后一个结点的后继指针指向头结点，且头结点前驱指针指向尾节点
    p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}

// 删除p结点的后继结点
bool DeleteNextDNode(DNode *p) {
    // 无效输入
    if(p == NULL) {
        return false;
    }
    // 找到p的后继结点q
    DNode *q = p->next;
    // 由于是循环双链表，所以在尾部时无需对最后一个结点进行特殊处理
    // 因为循环双链表最后一个结点的后继指针指向头结点，且头结点前驱指针指向尾节点
    // 用前驱结点的后继指针指向后继结点
    p->next = q->next;
    // 用q后继结点的前驱指针指向前驱结点
    q->next->prior = p;
    // 不要忘记释放空间！！！
    free(q);
    return true;
}

// 输出所有链表元素
void PrintList(DLinkList L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    DNode* p = L->next;
    while(p != NULL && p != L) {
        printf("%d  ", p->data);
        if(p->next == L) {
            break;
        }
        p = p->next;
    }
    printf("\n");
}

int main() {
    DLinkList L;
    InitDLinkList(L);
    PrintList(L);
    DNode *s1 = (DNode*)malloc(sizeof(DNode));
    s1->data = 5;
    s1->next = NULL;
    DNode *s2 = (DNode*)malloc(sizeof(DNode));
    s2->data = 3;
    s2->next = NULL;
    InsertNextDNode(L, s1);
    InsertNextDNode(L, s2);
    PrintList(L);
    DeleteNextDNode(L);
    PrintList(L);
}

3.3 运行截图

在这里插入图片描述

【2023王道数据结构】【线性表—page40—20】C、C++完整实现（可直接运行）
优快云 精品推荐
04-29 645
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ 题目： 设头指针为L的带有表头结点的非循环双向链表，其每个结点中除有pred（前驱指针）、data（数据）和next（后继指针）域外，还有一个访问频度域freq。在链表被启用前，其值均初始化为零。 解题思路： >双链表的插入、删除 代码实现： #include <iostream> using namespace std; typed.
【2023王道数据结构】【线性表】【P18】【02】C、C++完整实现（可直接运行）
优快云 精品推荐
04-25 1438
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ 题目： 解题思路： >由于题目要求算法的空间复杂度为O(1)，所以肯定是不能开辟新的数据进行复制的 >所以这里定义个临时变量，用于保存当前值 >不断交换首尾对应位置的元素 >由于首尾对称，所以只需要循环表长的一半 代码实现： #include <iostream> using namespace std; #defin.
循环链表基本操作
04-15
输入多个字符，用顺序表保存，实现对表的操作，实现初始化，求表长度，求表中的第i个结点，输入一个字符，查找对应的结点，插入一个结点，删除一个结点，排序
数据结构_线性表_链式存储_单向循环链表的基本操作
iteye_14589的博客
05-06 242
1.概述： 对于一个循环链表来说,其首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。要转换一个循环链表，可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。再来看另一种方法，循环链表可以被视为“无头无尾”。这种列表很利于节约数据存储缓存， 假定你在一个列表中有一个对象并且希望所有其他对象迭代在一个非特殊的排列下。 指向整个列表的指针可以被称作访问指针。 用...
循环链表的基本操作
平人的博客
07-07 293
循环单链表带有头结点。循环单链表的操作与单链表基本相同。
考研数据结构——线性表（顺序表&链表）最全！含代码！
最新发布
给你糖ya的博客
03-20 2054
和顺序表相比，单链表是链式存储而不是顺序存储，即在内存中是离散存储的，每个结点除了存放数据元素外还要存放指向下一个节点的指针；不需要大片连续空间，改变容量方便；但是不可随机存取，要耗费一定空间存放指针。typedef struct DNode { //定义单链表的结点类型int data;//每个结点存放一个数据元素//prior指向前驱结点，next指向后继结点单链表的各个结点离散地分布在内存中的各个地方；静态链表会分配一整块连续的内存空间来存放各个结点，各个结点不一定连续但都在这一块内存中。
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
数据结构之线性表(顺序表与链表)--王道
weixin_64144469的博客
05-21 1125
目录 2.1线性表的定义和基本操作 2.1.1线性表的定义 2.1.2线性表的基本操作 2.2线性表的顺序表示 2.2.1顺序表的定义 2.2.2顺序表上基本操作的实现 2.3线性表的链式表示 2.3.1单链表的定义 2.3.2单链表上基本操作的实现 1.用头插法建立单链表 2.用尾插法 3.按序号查找结点值 4.按值查找表结点 5.插入结点操作 6.删除结点操作 7.求表长操作 2.3.3双链表 1.双链表的插入 2.双链表的删除 2.3.4循环链表...
带表头节点的链表基本操作
weixin_43795318的博客
02-17 691
/***************************************************** copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd.  File name： Author：Jerey_Jobs    Version:0.1    Date:  Description： Funcion List:  *****...
【C语言/数据结构】循环链表的基本操作
weixin_43488592的博客
12-04 1667
一.程序可实现 初始化 头插法建立 尾插法建立 清空 判空 销毁 输出 查找（按数值/位置） 插入（按数值/位置进行前/后插） 删除（按数值/位置） 求链表长度 ps：“按数值”默认操作对象是指顺序表中第一个同值的元素。 二.知识点 循环链表和单向链表的差别仅仅在于结束的标志不同： //单链表结束标志：最后一个节点指向空； //循环链表结束标志：最后一个节点指向头指针/头节点 故编程序的时候要着重...
【链表】循环链表的基础操作
lxylxylxy的博客
11-12 974
基础操作包括：初始化、头插、尾插、求链表长度、按位置插、判断是否为空、查找、删除、返回前驱后继下标，输出、清空、销毁。
循环链表的主要操作
m0_70159601的博客
05-18 217
循环单链表和循环双链表是由对应的单链表和双链表改造而来的,只需在终端结点和头结点间建立联系即可,需要注意的是,如果p指针沿着循环链表走,则判定p走到尾结点的条件也就不同了呦------至此链表就结束啦!循环双链表终端结点的next指针指向表头结点,头结点的prior指针指向表尾结点。循环单链表终端结点的next结点指针指向表头结点。就当是对前面所学的一个复习吧.
C 数据结构循环链表（带环链表）基本操作
牧野的博客
11-05 709
经典循环链表之约瑟夫问题：标号从1到n的n个人围成一个圈，从1开始计数到m的人退出圈子，然后从退出的下一个人开始接着从1计数，数到m的人后继续退出，最后只剩下一个人，求剩下人的编号。这便是约瑟夫问题的模型。 经典循环链表之魔术师发牌问题：魔术师手中有A、2、3……J、Q、K十三张黑桃扑克牌。在表演魔术前，魔术师已经将他们按照一定的顺序叠放好（有花色的一面朝下）。魔术表演过程为：一开始，魔术师数1...
循环单链表的基本操作
罗小黑の窝
04-30 934
循环单链表所尊崇的结点如图 所实现的功能如下： 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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Silver Star

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

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

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

打赏作者

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

抵扣说明：

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

余额充值