【数据结构】线性表-循环链表（图解、c++、java）

已于 2022-06-07 11:42:08 修改
阅读量1.8k 收藏 4
点赞数 1
分类专栏： URLeisure的数据结构之旅 文章标签： 链表 数据结构 java c++ 图解法
于 2022-01-17 14:13:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50564032/article/details/122537217
版权

文章目录

GitHub同步更新（已分类）：Data_Structure_And_Algorithm-Review

公众号：URLeisure 的复习仓库
公众号二维码见文末

以下是本篇文章正文内容，下面案例可供参考。

什么是循环链表？

  • 单链表中，只能向后，不能向前。

  • 如果从当前节点开始，无法访问该节点前面的节点，而最后一个节点的指针指向头节点，形成一个环，就可以从任何一个位置出发，访问所有的节点，这就是循环链表。

  • 循环链表和普通链表的区别：循环链表的最后一个节点的后继指针指向了头节点。

循环链表的存储方式（图解）

  • 单向循环链表的最后一个节点的next域不能为空，而是指向头节点。
    单向循环链表
  • 双向循环链表除了让最后一个节点的后继指针指向第一个节点外，还要让头节点的前驱指向最后一个节点。
    双向循环链表

循环链表的基本操作

  • 因为循环链表的取值、查找代码没有改变，这里就不再写了。

  • 首先定义一个结构体（内部类），包含数据域与指针域。

c++代码如下（示例）：

typedef struct LNode{
    int data;
    LNode *next;
}*LinkList;

java代码如下（示例）：

public static class LNode{
 	int date;
	LNode next;
}

1.初始化

  • 循环链表的初始化是指构建一个空表。先创建一个头节点，不存储数据，然后令其指针域指向自己。

    • 单向循环链表

单

  • 双向循环链表
    在这里插入图片描述

c++代码如下（示例）：

bool Init(LinkList &L){
    L = new LNode;
    if(!L){
        return false;
    }
    L->next = L;
    L->data = 0;
    return true;
}

java代码如下（示例）：

public static LNode init(LNode L){
	LNode lNode = new LNode();
    lNode.next = lNode;
    lNode.data = 0;
    return lNode;
}

2.创建

  • 循环链表的创建过程与单链表，双链表相同。

  • 我们以头插法为例。
    头插法

c++代码如下（示例）：

void Create_H(LinkList &L,int n){
    LinkList s;
    while(n--){
        s = new LNode;
        cin >> s->date;
        //新节点next替换头节点next
        s->next = L->next;
        L->next = s;
    }
}

java代码如下（示例）：

public static void create_H(LNode L,int n){
    LNode s;
    Scanner sc = new Scanner(System.in);
        while(n-- > 0){
        s = new LNode();
        s.data = sc.nextInt();
        s.next = L.next;
        L.next = s;
    }
}

3.插入

  • 插入也是相同的，只是在插入到最后一个节点时判断改一下。
    插入

c++代码如下（示例）：

bool Insert(LinkList &L,int i,int e){
    LinkList s, p = L;
    int j = 0;
    while(p->next != L && j < i - 1){
        p = p->next;
        j++;
    }
    if(j != i - 1){
        return false;
    }
    s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

java代码如下（示例）：

public static boolean insert(LNode L,int i,int e){
    LNode s, ​p = L;
    int j = 0;
    while(p.next ​!= L && j < i - 1){
        p = p.next;
        j++;
    }
    if(j != i - 1){
        return false;
    }
    s = new LNode();
    s.data = e;
    s.next = p.next;
    p.next = s;
    return true;
}

4.删除

  • 删除也是相同的，只是在删除最后一个节点时判断改一下。

删除

c++代码如下（示例）：

bool Delete(LinkList &L,int i,int &e){
    LinkList q,p = L;
    int j = 0;
    while(p->next != L && j < i - 1){
        p = p->next;
        j++;
    }
    if(j != i-1){
        return false;
    }
    q = p->next;
    p->next = q->next;
    e = q->data;
    delete q;
    return true;
}

java代码如下（示例）：

public static int delete(LNode L,int i){
    LNode q, ​p = L;
    int j = 0;
    while(p.next != L && j < i - ​1){
        p = p.next;
        j++;
    }
    if(j != j - ​1){
        return -1;
    }
    q = p.next;
    p.next = q.next;
    return q.data;
}

5.打印

  • 打印非常简单，直接上代码。

c++代码如下（示例）：

void Print(LinkList L){
    LinkList p = L->next;
    while(p != L){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

java代码如下（示例）：

public static void print(LNode L){
    LNode p = L.next;
    while(p != L){
        System.out.print(p.data + " ");
        p = p.next;
    }
    System.out.println();
}

6.释放内存

  • c++需要手动释放内存，而java不需要。

c++代码如下（示例）：

void Destroy(LinkList &L){
    LinkList tmp;
    for(LinkList cur = L->next; cur != NULL; ){
        tmp = cur;
        cur = cur->next;
        delete tmp;
    }
    delete L;
}

完整代码

c++代码如下（示例）：

​​#include<iostream>
​
using namespace std;
​
typedef struct LNode {
    int data;
    LNode *next;
} *LinkList;
​
bool Init(LinkList &L) {
    L = new LNode;
    if (!L) {
        return false;
    }
    L->next = L;
    L->data = 0;
    return true;
}
​
void Create_H(LinkList &L, int n) {
    LinkList s;
    while (n--) {
        s = new LNode;
        cin >> s->data;
        s->next = L->next;
        L->next = s;
    }
}
​
bool Insert(LinkList &L, int i, int e) {
    LinkList s, p = L;
    int j = 0;
    while (p->next != L && j < i - 1) {
        p = p->next;
        j++;
    }
    if (j != i - 1) {
        return false;
    }
    s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
​
bool Delete(LinkList &L, int i, int &e) {
    LinkList q, p = L;
    int j = 0;
    while (p->next != L && j < i - 1) {
        p = p->next;
        j++;
    }
    if (j != i - 1) {
        return false;
    }
    q = p->next;
    p->next = q->next;
    e = q->data;
    delete q;
    return true;
}
​
void Print(LinkList L) {
    LinkList p = L->next;
    while (p != L) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
​
void Destroy(LinkList &L) {
    LinkList tmp;
    for (LinkList cur = L->next; cur != L;) {
        tmp = cur;
        cur = cur->next;
        delete tmp;
    }
    delete L;
}
​
int main() {
    LinkList L;
    int choose = -1;
    int i, e, n;
    
    Init(L);//初始化
    
    cout << "输入元素个数：" << endl;
    cin >> n;
    cout << "依次输入要插入的元素" << endl;
    Create_H(L, n);
    cout << "双向链表表创建成功！" << endl;
​
    cout << "1 .插入\n";
    cout << "2 .删除\n";
    cout << "3 .输出\n";
    cout << "0 .退出\n";
    while (choose != 0) {
        cout << "请选择！" << endl;
        cin >> choose;
        switch (choose) {
            case 1:
                cout << "请输入要插入的位置和要插入的元素" << endl;
                cin >> i >> e;
                if (Insert(L, i, e)) {
                    cout << "插入成功！" << endl;
                } else {
                    cout << "插入失败！" << endl;
                }
                break;
            case 2:
                cout << "请输入要删除的位置i" << endl;
                cin >> i;
                if (Delete(L, i, e)) {
                    cout << "成功删除" << e << endl;
                } else {
                    cout << "删除失败！" << endl;
                }
                break;
            case 3:
                Print(L);
                break;
            case 0:
                cout << "成功退出" << endl;
                break;
        }
    }
    Destroy(L);
    return 0;
}

java代码如下（示例）：

import java.util.Scanner;

public class A {
    public static class LNode {
        int data;
        LNode next;
    }

    public static LNode init(LNode L) {
        LNode lNode = new LNode();
        lNode.next = lNode;
        lNode.data = 0;
        return lNode;
    }

    public static void create_H(LNode L, int n) {
        LNode s;
        Scanner sc = new Scanner(System.in);
        while (n-- > 0) {
            s = new LNode();
            s.data = sc.nextInt();
            s.next = L.next;
            L.next = s;
        }
    }

    public static boolean insert(LNode L, int i, int e) {
        LNode s, p = L;
        int j = 0;
        while (p.next != L && j < i - 1) {
            p = p.next;
            j++;
        }
        if (j != i - 1) {
            return false;
        }
        s = new LNode();
        s.data = e;
        s.next = p.next;
        p.next = s;
        return true;
    }

    public static int delete(LNode L, int i) {
        LNode q, p = L;
        int j = 0;
        while (p.next != L && j < i - 1) {
            p = p.next;
            j++;
        }
        if (j != j - 1) {
            return -1;
        }
        q = p.next;
        p.next = q.next;
        return q.data;
    }

    public static void print(LNode L) {
        LNode p = L.next;
        while (p != L) {
            System.out.print(p.data + " ");
            p = p.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        E e = new E();
        LNode L = new LNode();
        int n, x, i;
        Scanner sc = new Scanner(System.in);
        L = init(L);
        
        System.out.println("输入元素个数：");
        n = sc.nextInt();
        System.out.println("依次输入要插入的元素");
        create_H(L, n);
        System.out.println("创建成功！");
        System.out.print("1.插入\n2.删除\n3.打印\n0.退出\n");
        int choose = -1;
        while (choose != 0) {
            System.out.println("请输入");
            choose = sc.nextInt();
            switch (choose) {
                case 1:
                    System.out.println("请输入要插入的位置和元素");
                    i = sc.nextInt();
                    x = sc.nextInt();
                    if (insert(L, i, x)) {
                        System.out.println("插入成功！");
                    } else
                        System.out.println("插入失败！");
                    break;
                case 2:
                    System.out.println("请输入要删除的位置");
                    i = sc.nextInt();
                    System.out.println("已删除" + delete(L, i));
                    break;
                case 3:
                    print(L);
                    break;
                case 0:
                    break;
            }
        }
    }
}

总结

优点：

  1. 链表是动态存储，不需要预先分配最大空间
  2. 插入删除不需要移动元素

缺点：

  • 每次动态分配一个节点时，节点的地址都是不连续的，需要有指针域记录下一个节点的地址，指针域需要占用一个 int 的空间，因此存储密度低（数据所占空间 ÷ 节点所占总空间）

双向循环链表和单向循环链表的改法基本相同，所以只发了单向循环链表的代码。

关注公众号，感受不同的阅读体验

请添加图片描述

下期预告：栈链

扑腾的江鱼
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解循环链表（数据结构C语言）
m0_59068067的博客
10-15 1232
本文简单介绍了循环链表的基本概念，特点以及基础运算，并附上了代码以及结果，希望以后复习时可以加深自己的印象；在运行过程中，总有一些卡壳的部分，在朋友的指导下，修改代码并顺利完成结果。
数据结构线性表-顺序表（c++、java）.pdf
11-12
顺序表是一种基本的数据结构，它在线性表的基础上采用了顺序存储的方式...在实际编程中，应考虑优化这些操作的效率，例如通过数组扩容策略减少频繁的内存分配，或者使用其他数据结构（如链表）来提高插入和删除的效率。
详解循环链表
wjk200204的博客
10-14 1033
循环链表是由多个节点组成的，每个节点都指向下一个节点，最后一个节点指向第一个节点。Node* head;Node* tail;int length;
循环链表初始化（带头结点和不带头结点）、插入、删除
最新发布
weixin_65075140的博客
05-23 168
[代码]循环链表初始化（带头结点和不带头结点）、插入、删除
循环链表详解
Q2076530986的博客
10-15 880
循环链表是一种特殊的链表结构。循环单链表是单链表的另一种形式，它与普通链表不同的地方在于，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。这也就意味着，在循环链表中，每个节点都有前驱节点和后继节点。循环链表既可以向前遍历，也可以向后遍历。循和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。
数据结构--循环链表
hyill的博客
01-28 275
【代码】数据结构--循环链表。
循环链表（c语言）
weixin_55668080的博客
10-14 266
Node* head;Node* tail;int length;
【数据结构】循环链表
debug...
08-16 417
循环链表以及解决
c/c++数据结构-线性表-链表
04-26
数据结构实验线性表当中的链表结构实现，带有详细注释，小白也能看得懂
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
C++ 数据结构线性表-数组实现
08-30
总的来说，C++中的线性表数组实现涉及到了动态内存分配、对象生命周期管理、数组操作以及基本数据结构的操作方法实现。这样的实现允许高效地访问和修改数组内的元素，但由于数组大小固定，插入和删除操作在表满或...
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构--线性表（顺序表、单链表、双链表、循环链表、静态链表）
weixin_46858088的博客
07-03 1348
线性表是具有相同数据类型的n (n>=0）个数据元素的有限序列，其中n为表长，当n = 0时线性表是一个空表。若用 L 命名线性表，则其一般表示为注1.Ai 是线性表中的 “第 i 个” 元素线性表中的位序(位序从1开始,数组下标从0开始2.A1是表头元素;an是表尾元素。3.除第一个元素外，每个元素有且仅有一个直接前驱;除最后一个元素外，每个元素有且仅有一个直接后继顺序表――用顺序存储的方式实现线性表顺序存储。
单链表的多语言表达：C++、Java、Python、Go、Rust
汉阳Hann's Home
07-30 6723
是一种链式数据结构，由一个头节点和一些指向下一个节点的指针组成。每个节点包含一个数据元素和指向下一个节点的指针。头节点没有数据，只用于表示链表的开始位置。单链表相对于数组的优点是插入和删除元素时不需要移动其他元素，时间复杂度为O(1)。但是，在查找元素时，单链表比数组要慢，时间复杂度为O(n)。
【c++版数据结构】之循环单链表的实现（带头结点以及尾节点）
weixin_34138521的博客
06-30 190
所实现的循环单链表的结构例如以下图所看到的： 循环单链表的实现，和上一篇文章单链表的实现大致同样点击打开链接，略有差别： 1：循环推断的条件不再是s == NULL或者s-&gt;next == NULL,而是他们是否等于头指针。2: 断开链表时的处理，尾节点的next不是NULL，而是指向头结点 详细细节參考上一篇文章 头文件：SCList.h #ifndef SC...
线性表的链式存储结构——循环链表
m0_59469991的博客
07-12 259
线性表的链式存储结构——循环链表
【C++】【五】循环链表
格物致知
11-16 343
【C++】【五】循环链表
图解循环链表
吾竹清风2017
09-10 1001
插入的3种场景： 第一种： 第二种： 第三种： 删除的3种场景
趣说数据结构 —— 3.线性表中的循环链表与双向链表
Smileyan's blog
04-29 6949
数据结构之循环链表与双向链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

扑腾的江鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值