数据结构与算法-循环链表详解

最新推荐文章于 2023-10-15 19:27:59 发布
最新推荐文章于 2023-10-15 19:27:59 发布
阅读量679 收藏
点赞数
分类专栏： # 算法与数据结构Java版 文章标签： 链表 指针 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shark_chili3007/article/details/107785630
版权

单项循环链表

图解

在这里插入图片描述

实现

步骤分析

由于之前已经写过了单链表单向链表，而单向循环链多数操作和单链表操作一致，所以我们只需基于之前的代码进行修改添加结点和删除结点的操作即可。

代码范例

添加操作
有元素的情况下，向0索引位置插入元素

如下图所示：

  1. 新结点的next指向0索引位置的元素
  2. 尾元素的next指针指向新结点
  3. first指针指向新结点

在这里插入图片描述

链表没有元素的情况下向0索引位置插入元素

如下图所示，操作步骤为：

1. 新结点的next指向自己
2. first的next指针指向新结点

在这里插入图片描述

常规插入(包括插入链表尾部)

如下图所示，操作步骤为:

		1. 新结点next指向指定索引位置的原元素
		2. 原元素的前驱结点指向新结点

在这里插入图片描述

代码实现
  @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        if (index == 0) {
            Node<E> newNode = new Node<E>(element, first);
            Node<E> lastNode = (size == 0) ? newNode : findNode(index - 1);
            lastNode.next = newNode;
            first = newNode;

        } else {
            Node<E> preNode = findNode(index - 1);
            Node<E> newNode = new Node<E>(element, preNode.next);
            preNode.next = newNode;
        }
        size++;
    }
删除操作
过程图解
链表元素大于1的情况下删除0索引位置元素

如下图所示，操作步骤为：

 1. 尾结点指向首结点的下一节点
 2. first指向首结点的下一节点

在这里插入图片描述

链表元素只有1的情况下删除0索引元素

如下图所示，将first指针置空即可

在这里插入图片描述

常规删除

如下图所示，将待删结点的前驱结点指向待删结点的后继节点即可
在这里插入图片描述

代码实现
 @Override
    public E remove(int index) {
        rangeCheck(index);

        Node<E> delNode = first;
        if (index == 0) {
            if (size == 1) {
                first = null;
            } else {
                Node<E> lastNode = findNode(size - 1);
                lastNode.next = first.next;
                first = first.next;
            }
        } else {
            Node<E> prevNode = findNode(index - 1);
            delNode = prevNode.next;
            prevNode.next = delNode.next;
        }
        size--;
        return delNode.element;
    }

完整代码

package com.study.Circle;

import com.study.singlelinkDemo.AbstractList;

/**
 * Created by Zsy on 2020/8/4.
 */
public class SingleCirecleLinkList<E> extends AbstractList<E> {
    private Node<E> first;

    private static class Node<E> {
        E element;
        Node<E> next;

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(element).append("_").append(next.element);
            return sb.toString();
        }
    }


    @Override
    public void clear() {
        this.first = null;
        size = 0;
    }

    @Override
    public E get(int index) {

        return findNode(index).element;
    }

    public Node<E> findNode(int index) {
        rangeCheck(index);
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    @Override
    public E set(int index, E element) {
        rangeCheck(index);
        Node<E> node = findNode(index);
        E oldNode = node.element;
        node.element = element;


        return oldNode;
    }

    @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        if (index == 0) {
            Node<E> newNode = new Node<E>(element, first);
            Node<E> lastNode = (size == 0) ? newNode : findNode(index - 1);
            lastNode.next = newNode;
            first = newNode;

        } else {
            Node<E> preNode = findNode(index - 1);
            Node<E> newNode = new Node<E>(element, preNode.next);
            preNode.next = newNode;
        }
        size++;
    }

    @Override
    public E remove(int index) {
        rangeCheck(index);

        Node<E> delNode = first;
        if (index == 0) {
            if (size == 1) {
                first = null;
            } else {
                Node<E> lastNode = findNode(size - 1);
                lastNode.next = first.next;
                first = first.next;
            }
        } else {
            Node<E> prevNode = findNode(index - 1);
            delNode = prevNode.next;
            prevNode.next = delNode.next;
        }
        size--;
        return delNode.element;
    }

    @Override
    public int indexOf(E element) {

        Node<E> node = first;
        if (element == null) {
            for (int i = 0; i < size; i++) {
                if (node == null) return i;
                node = node.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element))//防止空指针异常
                    return i;
                node = node.next;
            }
        }

        return ELEMENT_NOT_FOUND;
    }


    @Override
    public String toString() {
        Node<E> node = this.first;
        String statrStr = String.format("size: %d [", size);
        StringBuilder result = new StringBuilder();
        result.append(statrStr);
        for (int i = 0; i < size; i++) {
            if (i != 0) result.append(",");
            result.append(node.element);
            node = node.next;

        }
        result.append("]");
        return result.toString();
    }

}

双向循环链表

图解

在这里插入图片描述

实现

添加操作

常规添加
0索引位置添加

如下图所示，操作步骤为：

1.  新结点指向首结点所指向的元素
2. 尾结点的next指针指向新结点
3. first指针指向新结点

在这里插入图片描述

常规添加

如下图所示，操作步骤为：

1. 新结点指向指定索引的原结点及其前驱结点
2. 原结点的prev指针指向新结点
3. 原结点的前驱结点的next指针指向新结点

在这里插入图片描述

尾部添加

与首部添加同理，只是将first指向新结点改为last指向新结点
因为是否是尾部添加的判定条件为:index == size尾部添加还需要考虑一个情况是当前链表为空的情况。具体情况如下图所示，操作步骤为：

1. first和last都指向新结点
2. 新结点两个指针都指向自己

在这里插入图片描述

实现代码
  @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);


        if (index == size) {
            Node<E> oldLastNode = last;
            last = new Node<E>(oldLastNode, element, first);
            if (oldLastNode == null) {
                first = last;
                first.next = first;
                first.prev = first;
            } else {
                oldLastNode.next = last;
                first.prev = last;
            }
        } else {
            Node<E> node = findNode(index);
            Node<E> prev = node.prev;
            Node<E> newNode = new Node<E>(prev, element, node);
            prev.next = newNode;
            node.prev = newNode;

            if (index == 0) {
                first = newNode;
            }
        }
        size++;
    }

删除操作

删除操作的情况
1. 尾部删除：常规删除操作后，修改last指针指向即可
2. 首部删除：常规删除操作后，修改first指针指向即可
3. 常规删除
4. 只剩下一个元素的删除：first、last指针都置空
实现代码
 @Override
    public E remove(int index) {
        rangeCheck(index);
        Node<E> delNode = findNode(index);
        E removeNode = remove(delNode);
        return removeNode;
    }

    private E remove(Node<E> node) {
        if (size == 1) {
            first = null;
            last = null;
        } else {
            Node<E> prev = node.prev;
            Node<E> next = node.next;
            prev.next = next;
            next.prev = prev;

            if (node == first) {
                first = next;
            }

            if (node == last) {
                last = node;
            }
        }

        size--;
        return node.element;
    }

练习案例

约瑟夫问题

如下图所示，用双向链表实现，每次指针挪动三步，并移除该元素的操作
在这里插入图片描述

实现步骤

1. 加入current指针
2. 添加删除方法
3. 添加初始化current方法
4. 添加重置current指针方法

实现核心代码块

  private Node<E> current;


    public void reset() {
        current = first;
    }

    public E CurrentMoveToNext() {
        if (CurrentIsNullPoint()) return null;

        current = current.next;
        System.out.println(" move to"+current.element);
        return current.element;
    }

    public boolean CurrentIsNullPoint() {
        return current == null;
    }

    public E removeCurrentNode() {
        if (CurrentIsNullPoint()) return null;

        Node<E> currentNext = current.next;
        E removeValue = remove(current);

        if (size == 0)
            current=null;
        else
            current =currentNext;

        return removeValue;
    }
shark-chili
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
数据结构之线性表(六)——循环链表
daocaoren_的博客
07-20 899
循环链表的定义 1.概念与特点 循环链表：是一种头尾相接的链表。 表中的最后一个结点的指针域指向头结点，整个链表形成环状结构。 优点：从表中任意一个结点出发均可找到表中其他结点。 补充：        由于循环链表中没有NULL指针，所以涉及到遍历操作时，其终止条件不再像单链表那样判断p或者p->next是否为空，而是判...
C语言链式存储之循环链表
sinat_38205774的博客
08-30 251
目录 1.什么是循环链表 2.创建循环链表 3.合并循环链表 4.打印链表 5.主函数 1.什么是循环链表 循环链表是以单链表为原型，单链表中头结点和未结点是不能直接关联的，现在循环链表让尾结点直接指向头结点，形成一个圈，实现单向循环。 2.创建循环链表 要点：<1>创建一个头结点，后面依次添加结点和单链表相同； <2&gt...
循环链表详解
Q2076530986的博客
10-15 839
循环链表是一种特殊的链表结构。循环单链表是单链表的另一种形式，它与普通链表不同的地方在于，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。这也就意味着，在循环链表中，每个节点都有前驱节点和后继节点。循环链表既可以向前遍历，也可以向后遍历。循和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。
【数据结构】三、循环链表
lieam的博客
07-13 1788
fa
循环链表详解（C语言）
m0_55698213的博客
10-14 1031
本文主要讲述循环链表的基本定义特点以及一些常见操作并使用C语言代码对其进行实现。如何使用C语言代码去创建循环链表、插入头为节点、删除元素、输出链表长句、打印链表等基本运算。本文仅仅主要介绍了循环链表的概念、特点、运算以及循环链表的优缺点比较。特别注意当我们在实现循环连表时， 循环单链表没有明显的结束条件，很容易陷入死循环。此时，我们可以设置一个标记点作为循环的标记，当我们知道表长，我们也可以设置一个计数器来结束循环。
Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
09-21
主要介绍了Python数据结构与算法之链表定义与用法,结合具体实例形式较为详细的分析了单链表、循环链表等的定义、使用方法与相关注意事项,需要的朋友可以参考下
Java数据结构与算法-单链表 新浪，腾讯面试题详解
12-22
第二题：我们可以在第一题的基础上，在获取到了链表的长度后，只需要考虑倒数第K个节点是从前面开始第几个节点，我们就循环几次不就可以了？注意如果你的下标从0开始循环那就size – k就可以了，如果你是从1开始的...
JS中的算法与数据结构之链表(Linked-list)实例详解
12-09
本文实例讲述了JS中的算法与数据结构之链表(Linked-list)。分享给大家供大家参考，具体如下： 链表(Linked-list) 前面我们讨论了如何使用栈、队列进行存数数据，他们其实都是列表的一种，底层存储的数据的数据结构都...
数据结构（超详细讲解！！）第三节 循环链表
2201_76115387的博客
10-07 539
循环链表
详解循环链表
wjk200204的博客
10-14 707
循环链表是由多个节点组成的，每个节点都指向下一个节点，最后一个节点指向第一个节点。Node* head;Node* tail;int length;
详解循环链表（数据结构C语言）
最新发布
m0_59068067的博客
10-15 787
本文简单介绍了循环链表的基本概念，特点以及基础运算，并附上了代码以及结果，希望以后复习时可以加深自己的印象；在运行过程中，总有一些卡壳的部分，在朋友的指导下，修改代码并顺利完成结果。
【数据结构】带尾节点的循环链表
ZXC
07-10 2053
#include&lt;iostream&gt; using namespace std; struct Node { int data; Node *next; }; typedef Node* LinkList; void init(LinkList *L); bool insert(LinkList *L, int location, int data); void show(Li...
数据结构---循环链表
RookiChen的博客
04-30 192
循环链表与普通链表的区别就是将链表的尾节点的下一个指向链表的头节点，同时判断遍历链表结束的条件也会改变，这里可以采用do while的形式进行遍历，具体实现可以参考下面的Output函数。 删除时要考虑两种情况，一是删除中间节点和尾节点，第二个是删除头节点，这里只细说一下删除头节点的情况，删除头节点时需将链表尾节点的指针指向头节点的下一个，然后释放头节点，并将头节点置空 详细代码如下：共有两个类，一个是node类，一个是list类 #include <iostream> #inc..
数据结构（六）——循环链表
weixin_34210740的博客
01-21 1382
数据结构（六）——循环链表 一、循序链表简介 1、循环链表的定义 循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。循环链表的逻辑关系图如下： 2、循环链表的设计实现 循环链表的设计实现要点：A、通过模板定义CircleList，继承自LinkedListB、定义连接链表首尾的内部函数C、实现首元素的插入和删除操...
图解循环链表
吾竹清风2017
09-10 981
插入的3种场景： 第一种： 第二种： 第三种： 删除的3种场景
循环链表详解(循环单链表/循环双链表)
热门推荐
Curz酥的博客
10-05 1万+
王道数据结构笔记
循环链表的操作详解
lixin_com的博客
09-13 4536
一、概述 循环链表：循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 从上图看出循环链表有两个成员：data 和 next 由此可创建循环链表和它的一些基本操作如下： 注明：它的操作其实与单链的操作差不多，只要注意判断标志即可。 #pragma once //循环链表,尾节点的next指向头 typedef struct C
数据结构与算法单向循环链表
09-20
单向循环链表是一种特殊的链表，它与单链表相似，唯一的区别是最后一个节点指向链表的头节点，形成一个环。这种结构可以用来解决需要循环访问的问题，比如约瑟夫环问题。在单向循环链表中，每个节点除了保存数据元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

shark-chili

您的鼓励将是我创作的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值