链表（三）单向循环链表与双向循环链表

最新推荐文章于 2023-11-04 16:31:41 发布
最新推荐文章于 2023-11-04 16:31:41 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Demon_LMMan/article/details/113853934
版权

单向循环链表

观察单向链表和单向循环链表的区别：
在这里插入图片描述
在这里插入图片描述
显然，循环链表和普通链表的区别在于，尾节点的next指针指向了头节点。而对于这条指向的维护也只在于add和remove方法，因此循环链表仅仅在这个方法上有所不同。（普通链表的创建可见链表（一）用Java语言实现单向链表（有/无虚拟头节点））
add方法：

@Override
    public void add(int index, E element) {
        //考虑边界
        if(index==0){
            //新建节点指向first节点
            Node<E> newFirst= new Node<E>(element, first);
            //获取最后一个节点,若size为0则last就是newFirst
            Node<E> last= size==0?newFirst:node(size-1);
            first=newFirst;//并更新first节点
            last.next=first;
        }else{//由于添加时已经成环，尾部加入会自动连接头部
            //获取插入节点的先前节点
            Node<E> prev=node(index-1);
            //新建节点指向prev的next节点，prev指向新节点
            //如果prev是最后一个节点，则它本来就指向first
            prev.next=new Node<E>(element,prev.next);

        }
        size++;
    }

remove方法：

@Override
    public E remove(int index) {
        rangeCheck(index);
        Node<E> oldNode=first;
        //判断是否是第一个节点
        if(index==0){
            if(size==0){//只有一个节点
                first=null;
            }else{
                //获取最后一个节点
                Node<E> last=node(size-1);
                first=first.next;
                last.next=first;//跟新环
            }
        }else{//由于添加时已经成环，尾部删除时会自动连接头部
            //获取前驱节点
            Node<E> prev=node(index-1);
            //保存被移除节点数据
            oldNode=prev.next;
            //跳过next指向next.next，不需要更新环
            prev.next=prev.next.next;
        }
        size--;
        return oldNode.element;
    }

整体：

public class CircleLinkedList<E> extends AbstractList<E> {
    //定义普通内部类Node
    private class Node<E>{
        private E element;
        private 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("->");
            if(next!=null)
                sb.append(next.element);
            else
                sb.append("null");
            return sb.toString();
        }
    }

    private Node<E> first;//头节点

    @Override
    public int indexOf(E element) {
        Node<E> node=first;
        //如果元素为空，只需要考虑链表元素为空
        if(element==null){
            for(int i=0;i<size;i++){
                if(node.element==null)return i;
                node=node.next;
            }
        }else{//元素不为空则调用equals方法判断
            for(int i=0;i<size;i++) {
                if (element.equals(node.element)) return i;
                node=node.next;
            }
        }
        //未找到则返回常量-1
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public void clear() {
        //将头节点设为null,则头节点指向Node对象将被销毁，
        // 导致存储地址被销毁，直至所有Node对象被销毁
        first=null;
        size=0;
    }

    @Override
    public void add(int index, E element) {
        //考虑边界
        if(index==0){
            //新建节点指向first节点
            Node<E> newFirst= new Node<E>(element, first);
            //获取最后一个节点,若size为0则last就是newFirst
            Node<E> last= size==0?newFirst:node(size-1);
            first=newFirst;//并更新first节点
            last.next=first;
        }else{//由于添加时已经成环，尾部加入会自动连接头部
            //获取插入节点的先前节点
            Node<E> prev=node(index-1);
            //新建节点指向prev的next节点，prev指向新节点
            //如果prev是最后一个节点，则它本来就指向first
            prev.next=new Node<E>(element,prev.next);

        }
        size++;
    }

    @Override
    public E remove(int index) {
        rangeCheck(index);
        Node<E> oldNode=first;
        //判断是否是第一个节点
        if(index==0){
            if(size==0){//只有一个节点
                first=null;
            }else{
                //获取最后一个节点
                Node<E> last=node(size-1);
                first=first.next;
                last.next=first;//跟新环
            }
        }else{//由于添加时已经成环，尾部删除时会自动连接头部
            //获取前驱节点
            Node<E> prev=node(index-1);
            //保存被移除节点数据
            oldNode=prev.next;
            //跳过next指向next.next，不需要更新环
            prev.next=prev.next.next;
        }
        size--;
        return oldNode.element;
    }

    @Override
    public E get(int index) {
        Node<E> node=node(index);
        return node.element;
    }

    @Override
    public E set(int index, E element) {
        Node<E> node=node(index);
        E oldElement=node.element;
        node.element=element;
        return oldElement;
    }

    //获取索引为index的节点
    private Node<E> node(int index){
        rangeCheck(index);
        Node<E> node=this.first;
        for(int i=0;i<index;i++)
            node=node.next;
        return node;
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder("[");
        Node<E> node=first;
        for(int i=0;i<size;i++){
            if(i!=size-1)
                sb.append(node).append(" ,");
            else
                sb.append(node);
            node=node.next;
        }
        sb.append("]");
        return sb.toString();
    }
}

测试代码

public class CircleLinkedListTest {
    public static void main(String[] args) {
        CircleLinkedList<Integer> list=new CircleLinkedList<>();
        for(int i=0;i<10;i++)
            list.add(i);
        System.out.println(list);//[0,1,2,...,9]
        list.add(0,100);
        System.out.println(list);//[100,0,1,2,...,9]
        list.add(1,101);
        System.out.println(list);//[100,101,0,1,2,...,9]
        list.remove(0);
        System.out.println(list);//[101,0,1,2,...,9]
        list.remove(1);
        System.out.println(list);//[101,1,2,...,9]
        list.remove(list.size()-1);
        System.out.println(list);//[101,1,2,...,8]
        System.out.println(list.get(2));//2
        list.set(2,99);
        System.out.println(list.get(2));//99
        list.clear();
        System.out.println(list);//[]
    }
}

在这里插入图片描述
可以看到结果和预期相同。

双向循环链表

鉴于之前有写过双向链表，在此先对比一下双向循环链表和双向链表的区别。
在这里插入图片描述
在这里插入图片描述
双向循环链表主要将头节点和尾节点相连，而非双向链表那样，前后分别指向空。主要的区别也在于add(int index, E element)方法和remove(int index)方法（有关双向链表见 链表（二）用Java语言实现双向链表），具体实现如下：

add方法

@Override
public void add(int index, E element) {
    rangeCheckForAdd(index);//index合理范围0-size
    if(index==size){//从尾部插入节点
        Node<E> oldLast=last;//获取前节点
        last=new Node<E>(oldLast,element,null);
        if(oldLast==null)//若是插入的第一个节点
            first=last;
        else
            oldLast.next=last;
    }else{
        Node<E> next=node(index);//获取插入后的后节点
        Node<E> prev=next.prev;//获取前节点
        Node<E> node=new Node<E>(prev,element,next);
        next.prev=node;
        if(prev==null)//前节点为空，相当于从头插
            first=node;
        else
            prev.next=node;
    }
    size++;
}

remove方法

@Override
public E remove(int index) {
    rangeCheck(index);
    //获取要删除的节点
    Node<E> node=node(index);
    //前驱节点
    Node<E> prev=node.prev;
    //后继节点
    Node<E> next=node.next;
    if(prev==null)
        first=next;//修改头节点位置
    else
        prev.next=next;
    if(next==null)
        last=prev;
    else
        next.prev=prev;
    size--;
    return node.element;
}

整体：

public class DoubleLinkedList<E> extends AbstractList<E> {
        //定义普通内部类Node
        private class Node<E>{
            private E element;
            private Node<E> next;
            private Node<E> prev;

            public Node(Node<E> prev,E element, Node<E> next) {
                this.prev=prev;
                this.element = element;
                this.next = next;
            }
            @Override
            public String toString(){
                //用于打印链表的所有连接关系
                StringBuilder sb=new StringBuilder();
                if(prev!=null)
                    sb.append(prev.element);
                else
                    sb.append("null");
                sb.append("_").append(element).append("_");
                if(next!=null)
                    sb.append(next.element);
                else
                    sb.append("null");
                return sb.toString();
            }
        }

        private Node<E> first;//头节点
        private Node<E> last;//尾节点

        @Override
        public int indexOf(E element) {
            Node<E> node=first;
            //如果元素为空，只需要考虑链表元素为空
            if(element==null){
                for(int i=0;i<size;i++){
                    if(node.element==null)return i;
                    node=node.next;
                }
            /*while(node!=null){
                ...
                node=node.next;
            }*/
            }else{//元素不为空则调用equals方法判断
                for(int i=0;i<size;i++) {
                    if (element.equals(node.element)) return i;
                    node=node.next;
                }
            }
            //未找到则返回常量-1
            return ELEMENT_NOT_FOUND;
        }

        @Override
        public void clear() {
            //将头尾指针置空，所有节点对象将不被gc root对象引用
            //gc root对象，如被栈指针引用的对象
            last=null;
            first=null;
            size=0;
        }

        @Override
        public void add(int index, E element) {
            rangeCheckForAdd(index);//index合理范围0-size
            if(index==size){//从尾部插入节点
                Node<E> oldLast=last;//获取前节点
                last=new Node<E>(oldLast,element,null);
                if(oldLast==null)//若是插入的第一个节点
                    first=last;
                else
                    oldLast.next=last;
            }else{
                Node<E> next=node(index);//获取插入后的后节点
                Node<E> prev=next.prev;//获取前节点
                Node<E> node=new Node<E>(prev,element,next);
                next.prev=node;
                if(prev==null)//前节点为空，相当于从头插
                    first=node;
                else
                    prev.next=node;
            }
            size++;
        }

        @Override
        public E remove(int index) {
            rangeCheck(index);
            //获取要删除的节点
            Node<E> node=node(index);
            //前驱节点
            Node<E> prev=node.prev;
            //后继节点
            Node<E> next=node.next;
            if(prev==null)
                first=next;//修改头节点位置
            else
                prev.next=next;
            if(next==null)
                last=prev;
            else
                next.prev=prev;
            size--;
            return node.element;
        }

        @Override
        public E get(int index) {
            Node<E> node=node(index);
            return node.element;
        }

        @Override
        public E set(int index, E element) {
            Node<E> node=node(index);
            E oldElement=node.element;
            node.element=element;
            return oldElement;
        }

        //获取索引为index的节点
        private Node<E> node(int index){
            rangeCheck(index);//index的取值只能是0-size-1
            //判断从头往后还是从后往前获取节点更快
            if(index<(size>>1)){
                Node<E> node=this.first;
                for(int i=0;i<index;i++)
                    node=node.next;
                return node;
            }else{
                Node<E> node=this.last;
                for(int i=size-1;i>index;i--)
                    node=node.prev;
                return node;
            }
        }

        @Override
        public String toString() {
            StringBuilder sb=new StringBuilder("[");
            Node<E> node=first;
            while(node!=null){
                //判断是否是最后一个节点
                if(node.next!=null)
                    sb.append(node).append(" ,");
                else
                    sb.append(node);
                node=node.next;
            }
            sb.append("]");
            return sb.toString();
        }
}

通过打印节点的连接关系观察对错

public class DoubleCIircleTest {
    public static void main(String[] args) {
        DoubleCircleLinkedList<Integer> list=new DoubleCircleLinkedList<>();
        for(int i=0;i<10;i++)
            list.add(i);
        System.out.println(list);//[0,1,2,...,9]
        list.add(0,100);
        System.out.println(list);//[100,0,1,2,...,9]
        list.add(1,101);
        System.out.println(list);//[100,101,0,1,2,...,9]
        list.remove(0);
        System.out.println(list);//[101,0,1,2,...,9]
        list.remove(1);
        System.out.println(list);//[101,1,2,...,9]
        list.remove(list.size()-1);
        System.out.println(list);//[101,1,2,...,8]
        System.out.println(list.get(2));//2
        list.set(2,99);
        System.out.println(list.get(2));//99
        list.clear();
        System.out.println(list);//[]
    }
}

结果为：
在这里插入图片描述
可以发现节点的数据和前后连接关系都没有问题。

von Libniz
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python单向循环链表原理与实现方法示例
09-18
单向循环链表是一种特殊的链表结构，它的特点是最后一个节点的`next`指针不再指向`None`，而是指向链表的头节点，形成一个闭合的环状结构。这样的设计使得链表在某些特定场景下，如遍历或循环处理时更为便捷。 在...
Python单向链表和双向链表原理与用法实例详解
09-20
双向链表的创建与单向链表类似，只是每个节点还需要一个prev指针，初始状态下，头节点的prev指针指向None，尾节点的next指针也指向None。 2. 插入节点： 在双向链表中插入节点，除了要更新下一个节点的引用，还要...
单向链表与双向链表区别
大伟伟的博客
10-25 7860
单向链表： 由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为null,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。 双向链表： 对于双向链表来说，它的每个节点要指向“直接前驱”和“直接后继”，所以节点类需要含有两个指针域。指向直接前驱的指针使用pre表示，指向后继的指针使用next表示。双向链表是在单向链表基础上的一个改进，每个节点指向其直接前驱和直接后继节点。因此，从双向链表的任
循环链表（单循环、双循环）(数据结构与算法)
最新发布
AII_IIA的博客
11-04 2240
循环单链表与普通单链表的主要区别在于，循环单链表的尾节点的指针不是指向 nullptr，而是指向头节点，形成一个闭环。这意味着，在循环单链表中，可以通过尾节点的指针重新回到头节点。循环双链表与普通双链表的主要区别在于，循环双链表既具有双向链表的前驱和后继关系，也具有循环遍历的能力。
链表（单/双/单循环/双循环）
qq_44095715的博客
06-24 3013
文中链接附上java版代码 1.单链表 单链表是一种链式存储的数据结构，方便插入/删除数据元素，对比数组，在进行插入删除等操作时，更节省空间。单链表中每一个结点的构成都是由数据元素+指针构成的 2.单循环链表 单循环链表与单链表的区别就是，单循环链表的尾指针指向头结点，可以想象成一个环，首尾相连，这时候需要考虑两种情况： 1.不带头结点 2.带头节点 不带头节点的情况： 对比单链表，直接尾结点的指针指向头节点就好了 带头节点的情况： 尾结点指向头结点的下一个结点，头结点不保存数据。 3.双链表： 顾名思义，
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5192
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
找出链表的第一个公共结点 java_结构与算法(03)：单向链表和双向链表
weixin_39768444的博客
11-21 177
一、链表简介1、链表概念链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成，节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。2、基础特点内存存储逻辑结构特点描述物理存储上是无序且不连续的；链表是由多个节点以链式结构组成；逻辑层面上看形成一个有序的链路结构；链表结构解决...
单向循环链表
01-20
循环链表 循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点...
C语言中双向链表和双向循环链表详解
12-26
双向链表和双向循环链表 和单向链表相比，多了一个前驱结点。如果他为空，那么next和prior都指向自己。而对于双循环链表，只需要最后一个元素的next指向head->next，head->next的prior指向最后一个节点即可。 插入...
如何用C++实现双向循环链表
12-31
双向循环链表，即每个节点都拥有一前一后两个指针且头尾互链的链表。各种链表的简单区别如下：单向链表：基本链表；单向循环链表：不同于单向链表以 NULL 判断链表的尾部，单向循环链表的尾部链接到表头，因此当迭代...
单链表,双链表,循环单链表,循环双链表的(可重复)插入和(可重复)删除
11-22
最近在面试过程中总被问到链表的问题,因此这里把自己实现的链表操作上传给大家共享!包括单链表,双链表,循环单链表,循环双链表的(可重复)插入和(可重复)删除的完整实现,由c及Code::Blacks实现.
单向和双向循环链表实例（Josephus环问题）
04-13
Josephus问题可以描述为如下的一个游戏：N个人编号从1到N，围坐成一个圆圈，从1号开始传递一个热土豆，经过M次传递后拿着土豆的人离开圈子，由坐在离开的人的后面的人拿起热土豆继续进行游戏，直到圈子只剩下最后一个人。例如：M=0，N=5，则游戏人依次被清除，5号最后留下；如果M=1，N=5，那么被清除的人的顺序是2,4,1,5，最后剩下的是3号。
单链表与双向循环链表的区别
m0_72671017的博客
06-13 169
单链表与双向循环链表的不同（初始化方式不同，结构不同，遍历方式不同）
单链表，双链表，循环链表的区别
code changes world!
12-28 9508
单向链表（单链表） 单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则 指向一个空值NULL。 单向链表只可向一个方向遍历。查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以提前把一个节点的位置另外保存起来，然后直接访问。 双向链表,（双链表） 双向链表中不
链表——循环单链表，循环双链表及静态链表
薛定谔的猫的博客
04-18 3414
文章目录循环链表循环单链表循环双链表静态链表说明 循环链表  循环链表一般包括循环单链表和循环双链表，如下图所示： 循环单链表   循环单链表与单链表的区别在于，表中最后一个结点的指针不是NULL，而改为指向头结点，从而使整个链表形成一个环。   一般对循环单链表只设尾指针不设头指针，其原因是，如果设的是头指针，对表尾进行操作需要O(n)的时间复杂度，而若设的是尾指针r，那么r->next即为头指针，对表头与表尾进行操作都只需要O(1)的时间复杂度。  单链表与循环单链表：  详细的单链表操作请参
循环链表和双向链表
DLaugust的博客
08-13 615
一、循环链表 1、特点：从任意一个结点出发，可以访问到全部结点。 2、与单链表的区别：单链表最后一个结点指针域的指针指向空，循环链表则是最后一个结点指针域的指针指向头结点，当然如果该链表无头结点，指针就指向第一个结点。 下图为带有头结点的循环链表： 二、循环链表的操作 1、循环链表操作跟单链表操作类似，只是判断循环条件时，单链表是p->next是否为空，而循环链表则是p->next是否为头指针L。 2、两循环链表合并 ...
【数据结构与算法学习】线性表（顺序表、单链表、双向链表、循环链表）
Gefangenes的博客
06-09 1334
12345。
【循环链表】数据结构——单向循环链表和双向循环链表操作&笔记
皮皮不调皮的博客
03-23 8848
一、单向循环链表 将单链表的首尾节点相连就形成了单向循环链表。 1、单向循环链表的节点 2、单向循环链表的结构 单向循环链表只有一个节点时： 二、双向循环链表 1、双向循环链表示意图 2、双向循环链表节点设计 struct d_node{ int data; //数据域 struct d_node *next; struct d_node *prev; }; 3、双向循环链表的一般性结构 1）只有头结点的情况 2）有多个节点的情况 4、双向循环链表头插法插入节点 步骤： 1）p-&
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3113
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
循环链表与双向链表详解：基本操作与应用实例
循环链表适用于数据元素有环型结构的情况，插入和删除操作与单向链表类似，但查找时需要特别注意循环性，避免死循环。 - 判断链表为空或满的关键在于理解循环性，即检查当前节点的下一个节点是否等于头节点而非...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值