循环链表-线性表-数据结构和算法

最新推荐文章于 2024-10-03 21:40:01 发布
最新推荐文章于 2024-10-03 21:40:01 发布
阅读量125 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaogzhen/article/details/127560578
版权

文章目录

1 循环链表简介

循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。

循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。

循环链表的逻辑关系图如图2-1所示：在这里插入图片描述

2 循环链表实现

2.1 API

类名LinkList
构造方法LinkList()
成员方法1. public boolean add(E e)：添加元素
2. public void add(int index,E e)：指定位置添加元素
3. public void clear()：清空链表
4. public E get(int index)：获取指定索引位置的元素
5. public int indexOf(Object o)：返回元素在链表中的位置索引
6. public E remove(int index)：删除指定索引位置的元素
7. public boolean remove(Object o)：删除链表中的元素
8. public E set(int index,E e)：给指定索引位置节点设置值
9. public int size()：获取链表的大小
成员变量1. private int size：链表大小
2. private Node<E> first：链表头指针
3. private Node<E> last：链表尾指针
成员内部类1. private class Itr：迭代器
2. private static class Node<E>：节点类
类名Itr
构造方法Itr(int index)
成员变量1. private Node<E> lastReturned：上一个返回的节点
2. private Node<E> next：下一个节点
3. private nextIndex：下一个索引
成员方法1. public boolean hasNext()：是否有下一个节点
2.public E next()：下一个节点
3. public void remove()：移除当前节点
4. public void forEachRemaing(Consumer<? super E> action)

2.2 代码

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Consumer;

/**
 * @author Administrator
 * @version 1.0
 * @description 单向循环链表
 * @date 2022-10-24 21:09
 */
public class CircularList<E> {
    /**
     * 节点类
     * @param <E>
     */
    private static class Node<E> {
        E item;
        Node<E> next;
        Node(E item, Node<E> next) {
            this.item = item;
            this.next = next;
        }
    }

    private int size;
    private Node<E> first;
    private Node<E> last;

    public CircularList() {}

    /**
     * 添加元素e
     * @param e     目标元素
     * @return      添加是否成功
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    /**
     * 插入链表末尾
     * @param e     目标元素
     */
    private void linkLast(E e) {
        Node<E> l = last;
        Node<E> newNode = new Node<>(e, null);
        last = newNode;
        if (l == null) {
            first = newNode;
            newNode.next = newNode;
        } else {
            newNode.next = first;
            l.next = newNode;
        }
        size++;
    }

    /**
     * 插入链表头
     * @param e     目标元素
     */
    private void linkFirst(E e) {
        Node<E> f = first;
        Node<E> newNode = new Node<>(e, null);
        first = newNode;
        if (f == null) {
            last = newNode;
            newNode.next=newNode;
        } else {
            last.next = newNode;
            newNode.next = f;
        }
        size++;
    }

    /**
     * 指定索引位置插入元素
     * @param index     索引
     * @param e         目标元素
     */
    public void add(int index,E e) {
        checkPositionIndex(index);
        if (index == size) {
            linkLast(e);
        } else if (index == 0) {
            linkFirst(e);
        } else {
            linkAfter(e, nodeBefore(index));
        }
    }

    private Node<E> nodeBefore(int index) {
        Node<E> x = first;
        for (int i = 0; i < index - 1; i++) {
            x = x.next;
        }
        return x;
    }

    private void linkAfter(E e, Node<E> before) {
//        assert before != null;
        before.next = new Node<>(e, before.next);
    }

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

    /**
     * 检查位置索引是否合法
     * @param index     目标索引
     */
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }


    /**
     * 检查是否合法的索引
     * @param index     目标索引
     * @return          是否合法
     */
    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    /**
     * 情况链表
     */
    public void clear() {
        if (first == null) {
            return;
        }
        last.next = null;
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x = next;
        }
        first = last = null;
        size = 0;
    }

    /**
     * 获取指定索引处的元素
     * @param index     目标索引
     * @return          指定索引处的元素
     */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    /**
     * 返回元素在链表中的索引位置
     * @param o     目标元素
     * @return      目标元素在链表中的索引
     */
    public int indexOf(Object o) {
        if (size == 0) {
            return -1;
        }
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != last; x = x.next) {
                if (x.item == null) {
                    return index;
                }
                index++;
            }
            if (last.item == null) {
                return size - 1;
            }
        } else {
            for (Node<E> x = first; x != last; x = x.next) {
                if (o.equals(x.item)) {
                    return index;
                }
                index++;
            }
            if (o.equals(last.item)) {
                return size - 1;
            }
        }

        return -1;
    }

    /**
     * 移除链表指定索引位置的元素
     * @param index     目标索引
     * @return          目标索引位置的元素值
     */
    public E remove(int index) {
        checkElementIndex(index);
        if (index == 0) {
            return unlinkFirst();
        }
        return unlink(nodeBefore(index));
    }

    private E unlinkFirst() {
        // assert first != null;
        Node<E> f = this.first;
        if (size == 1) {
            first = last = null;
        } else {
            last.next = first = first.next;
        }
        E item = f.item;
        f.item = null;
        f.next = null;
        size--;
        return item;
    }

    private E unlinkLast() {
        // assert first != null;
        Node<E> l = last;
        if (size == 1) {
            first = last = null;
        } else {
            Node<E> prev = nodeBefore(size - 2);
            prev.next = first;
            last = prev;
        }
        E item = l.item;
        l.item = null;
        l.next = null;
        size--;
        return item;
    }

    private E unlink(Node<E> prev) {
        // assert prev != null && prev.next != null;
        Node<E> t = prev.next;
        Node<E> next = t.next;
        E item = t.item;
        t.item = null;
        t.next = null;
        prev.next = next;
        if (next == first) {
            last = prev;
        }
        size--;
        return item;
    }

    /**
     * 移除链表中的指定元素
     * @param o     目标元素
     * @return      是否移除成功
     */
    public boolean remove(Object o) {
        if (size == 0) {
            return false;
        }
        Node<E> prev = null;
        if (o == null) {
            for (Node<E> x = first; x != last; x = x.next, prev = x) {
                if (x.item == null) {
                    if (prev == null) {
                        unlinkFirst();
                    } else {
                        unlink(prev);
                    }
                    return true;
                }
            }
            if (last.item == null) {
                unlinkLast();
                return true;
            }
        } else {
            for (Node<E> x = first; x != last; x = x.next, prev = x) {
                if (o.equals(x.item)) {
                    if (prev == null) {
                        unlinkFirst();
                    } else {
                        unlink(prev);
                    }
                    return true;
                }
            }
            if (o.equals(last.item)) {
                unlinkLast();
                return true;
            }
        }
        return false;
    }

    /**
     * 设置指定索引位置元素的值
     * @param index     目标位置索引
     * @param e         要替换的值
     * @return          被替换的旧值
     */
    public E set(int index, E e) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = e;
        return oldVal;
    }

    /**
     * 返回链表的大小
     * @return  链表的大小
     */
    public int size() { return size; }
    
    /**
     * 判断链表是否为空
     * @return  
     */
    public boolean isEmpty() {
        return size == 0;
    }

    public Iterator<E> iterator() {
        return new Itr(0);
    }

    public Iterator<E> listIterator(int index) {
        checkElementIndex(index);
        return new Itr(0);
    }

    @Override
    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext()) {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext()) {
                return sb.append(']').toString();
            }
            sb.append(',').append(' ');
        }
    }

    private class Itr implements Iterator<E> {

        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;

        public Itr(int index) {
            next = node(index);
            nextIndex = index;
        }

        @Override
        public boolean hasNext() {
            return nextIndex < size;
        }

        @Override
        public E next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        @Override
        public void remove() {
            if (lastReturned == null) {
                throw new IllegalStateException();
            }
            Node<E> prev = node(nextIndex - 1);
            if (prev == null) {
                unlinkFirst();
            } else {
                unlink(prev);
            }
            lastReturned = null;
            nextIndex--;
        }

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while ( nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
        }
    }
}

3 约瑟夫问题

3.1 约瑟夫环解决

Josephu约瑟夫环问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

3.2 循环链表解决

public static void testJusephus() {
    // 初始化链表
    int size = 8, start = 5, count = 3;
    CircularList<Integer> jusephus = new CircularList<>();
    for (int i = 1; i <= size; i++) {
        jusephus.add(i);
    }
    System.out.println("初始数据:" + jusephus);
    int index = (start + count - 2);
    int[] nums = new int[size];
    int i = 0;
    int tsize = size;
    while (!jusephus.isEmpty()) {
        if (index > tsize - 1 ) {
            index = index % tsize;
        }
        int tmp = jusephus.remove(index);
        System.out.println(tmp);
        nums[i++] = tmp;
        index = index + count - 1;
        tsize--;
    }
    System.out.println("出队编号：" + Arrays.toString(nums));
    System.out.println("最终数据:" + jusephus);
}

4 后记

​ 如果小伙伴什么问题或者指教，欢迎交流。

❓QQ:806797785

⭐️源代码仓库地址：https://gitee.com/gaogzhen/algorithm

参考：

[1]百度百科.循环链表[EB/OL].2022-09-17/2022-10-08.

[2]黑马程序员.黑马程序员Java数据结构与java算法全套教程，数据结构+算法教程全资料发布，包含154张java数据结构图[CP/OL].p61~p64.

gaog2zh
关注
专栏目录
数据结构与算法系列--线性表
2302_77343936的博客
10-01 549
针对顺序表的缺点，一种改进的思路是让相邻元素间留有足够的余地，即所有的元素都不考虑相邻的位置，哪里有空位就空到哪里，而只是让每个元素都知道它下一个元素在哪儿就可以了，这样，假设我们在表中的第一个元素，我们便知道了第二个元素的内存地址，在第二个元素，知道第三个元素的内存地址，依此类推，通过遍历的形式便可以找到所有元素的内存地址。这种思想便是线性表链式存储结构建立的前提。1.线性链表:采用链式存储结构的线性表。
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
通过深入学习和实践，你可以更好地理解和掌握双向带头循环链表，这对于理解和解决更复杂的数据结构问题以及算法设计都至关重要。同时，这也是软件开发中不可或缺的基础知识，无论是开发操作系统、数据库，还是编写...
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法--线性表
qq_44175983的博客
08-27 545
每一个结点包括数据域和指针域，指针域的值为下一节点在数组中的位置（序号）。在线性表 L 中查找是否存在数据元素 e，返回第 1 个值与 e 相同的元素的位序，若不存在则返回 0。查找单链表中是否存在数据域为 e 的结点，若有则返回该结点的指针；（7）单链表适用于经常对数据进行插入/删除的操作的问题，不适合经常需要随机存取的问题。每个节点包括数据域和指针域，数据域中存储元素本身信息，指针域存储结点直接后继的地址。（2）插入：在双向链表中指针 p 指向的结点前插入新结点（注意每一步的顺序）。
算法和数据结构 - 线性表
暴力扬
01-26 965
线性表 线性表的定义和特点 线性表的例子 线性表的逻辑特征 案例引入 案例【2.1】一元多项式的运算：实现两个多项式加、减、乘运算 案例【2.2】稀疏多项式的运算 线性表的类型定义 基本操作： 线性表的顺序表示和实现 多项式的顺序存储结构类型定义 图书表的顺序存储结构类型定义 补充：元素类型说明 补充：数组静态分配 补充：数组动态分配 补充：C语言的内存动态分配 顺序表基本操作实现 补充：操作算法中用到的预定义常量和类型 顺序表基本操作的实现 顺序表上的查找操作 小结 顺序表(线性表的顺序存储结构)的特点
数据结构（二）----线性表（顺序表，链表）
weixin_69884785的博客
04-03 1447
数据结构（二）----线性表（顺序表，链表） 1.线性表的概念 2.线性表的基本操作 3.存储线性表的方式 （1）顺序表 •顺序表的概念 •顺序表的实现 静态分配： 动态分配： 顺序表的插入： 顺序表的删除： 顺序表的按位查找： 顺序表的按值查找： 顺序表的特点： （2）单链表 •单链表的实现 不带头结点的单链表： 带头结点的单链表： 单链表的插入： ▴按位序插入（带头结点） ▴按位序插入（不带头结点） ▴指定结点的后插操作 ▴指定结点的后插操作 单链表的删除：
算法&数据结构 - 线性表及其顺序存储结构
爱意随风起，风止意难平
07-10 1819
本篇主要介绍线性表相关理论及实例，包括线性表增删操作，顺序存储结构及其操作，本篇中量代码。
算法&数据结构 - 线性表及其链式存储结构
爱意随风起，风止意难平
07-16 1709
本篇主要介绍线性表另一种存储形式，链式存储结构及其操作方法，本篇中量代码。
数据结构和算法基础--线性表
A1L__的博客
01-17 495
数据结构和算法基础–线性表 数据结构 = 数据的逻辑结构+数据的存储结构+数据的运算 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-28ek7MfI-1642426292721)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211215231756058.png)] 线性表的定义和特点 线性表是具有相同特性的数据元素的一个有限序列 （a1,a2,a3,a4,a5,a6,a
数据结构-线性表（四）循环链表
北以晨光的博客
09-15 1199
数据结构-线性表（四）循环链表 本文介绍了单循环链表和双循环链表以及它们的代码实现； 还详细对比了顺序表和链表以及如何选取。
数据结构-线性表-循环链表，双向链表
qq_43627079的博客
11-03 323
一.循环列表 将单链表或者双链表的头尾结点链接起来，就是一个循环链表。 特点： 首尾相接的链表。 可以从任一节点出发，访问链表中的所有节点。 判断循环链表中尾结点的特点： q->next==first 1.循环列表的构建 ①头插法构建循环链表 first=new Node; //生成头结点 first->next=first; Node *s; for (int i=1; i&l...
算法-理论基础- 线性表- 循环链表（包含源程序）.rar
09-16
循环链表的应用广泛，例如在实现队列、栈、图形算法（如Floyd-Warshall算法）、模拟循环数据结构（如日历系统）等场景中都有所体现。源程序可能包含了循环链表的基本操作函数的实现，如创建链表、添加元素、删除元素...
数据结构小练习-线性表（下）
06-25
8. **线性表的应用**：线性表广泛应用于各种算法和数据结构中，如栈、队列、哈希表等。理解线性表的基本操作对于学习更复杂的数据结构至关重要。 在"day02_code"文件中，可能包含了实现上述操作的示例代码。通过...
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 366
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1070
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
Java.数据结构.TreeSet
最新发布
TJKFYY的博客
10-03 153
TreeSet是Java集合框架中的一部分，是基于TreeMap实现的。TreeSet保证了集合中的元素按照自然顺序或者通过提供的Comparator进行排序。：TreeSet会根据元素的自然顺序进行排序，确保集合中的元素总是处于有序状态，和TreeMap一样，我们同样可以通过重写Comparator方法来进行排序。：TreeSet中的元素是唯一的，不能重复。如果有两个元素相等，则后插入的元素不会出现在集合中。：TreeSet基于TreeMap实现，其时间复杂度为O(log n)。
【笔记】选择题笔记+数据结构笔记
m0_52024881的博客
09-30 571
连通分量是极大连通子图一个连通图的生成树是一个极小连通子图。
数据结构——初识树和二叉树
weixin_74209413的博客
09-26 1159
树是由根和子树组成，子树又是由子树的根和子树的子树组成，是一个递归的（嵌套的）结构。示意图如下：树的其他表现方式为何要重点研究每结点最多只有两个的树?二叉树的结构最简单，规律性最强;可以证明，所有树都能转为唯一对应的二又树，不失一般性。普通树(多又树)若不转化为二又树，则运算很难实现二叉树在树结构的应用中起着非常重要的作用，因为对二叉的许多操作算法简单，而任何树都可以与二叉树相互转换，这样就解决了树的存储结构及其运算中存在的复杂性。二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

gaog2zh

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

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

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

打赏作者

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

抵扣说明：

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

余额充值