链表（二）用Java语言实现双向链表

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

单向链表与双向链表

单向链表结构：
在这里插入图片描述

双向链表结构：
在这里插入图片描述
在之前的文章中已经完成了对单向链表的实现：用Java语言实现单向链表（有/无虚拟头节点） ，那么实现双向链表只需要在单链表的基础上做一些更改即可。

改动位置改动操作
private Node < E > last为LinkedList添加尾节点
private Node < E > prev为节点Node添加前驱节点
private Node node(int index)私有方法，获取索引为index的节点，增加从后向前查找节点
public void add(int index, E element)修改增加节点时前后节点的指向操作
public E remove(int index)修改删除节点时前后节点的指向操作

具体实现

last节点：

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

内部节点类Node :

//定义普通内部类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 node(int index)，用于获取索引为index的节点：

/获取索引为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;
    }
}

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();
        }
}

其中接口List和抽象类AbstractList见单链表：用Java语言实现单向链表（有/无虚拟头节点）

检验链表的正确性

此外在检验双向链表正确与否时，可以选择将所有节点的连接关系都打印出来，这样就可以很直观得判断链表结构是否有误。因此需要重写链表的toString方法与节点得toString方法。如下：

节点的toString方法：

 @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();
 }

链表的toString方法：

 @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();
}

经过测试可看到结果如下：
在这里插入图片描述

von Libniz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JAVA】双向链表详解
weixin_74999790的博客
06-04 3113
LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。每个数据节点都有两个指针，指向前驱和后继，所以，双向链表中的任意一个节点开始，都可以十分方便找到前驱节点和后继节点。
一步步带你用Java实现双向链表（超详细）
you do ,you win
04-21 1万+
文章目录什么是双向链表属性及方法节点Nodesize数据插入头插法 addFirst(T value)尾插法 addLast(T value)插入到指定下标位置add(int index)数据删除(返回被删除节点存储的值)删除头结点 removeFirst删除尾结点 removeLast删除指定下标节点remove（int index）获取指定下标位置节点的数据 getData（int index）获取链表长度遍历输出print()详细遍历输出清空链表实现细节 上一节说到了单链表,这一节我们来手写一个双向链
Java数据结构——代码实现双向链表的方法
chenchenchencl的博客
09-23 2440
一文速学双向链表方法的实现
java实现双向链表
qq_53933886的博客
10-08 346
java原生实现双向链表
双向链表的基本操作
热门推荐
crazy boy
07-27 3万+
学过单向链表的小伙伴都知道单向链表中的每一个节点有且只有一个指针，这个指针就是用来指向下一个节点的，单向链表顾名思义就是链表方向是单方向的，而本文要介绍的双向链表就是链表方向是双方向的，也就是双向链表中的每一个节点有两个指针，一个指针用来指向上一个节点（前驱），另一个指针用指向下一个节点（后继）。   本文主要是总结一下自己对双向链表的基本操作，当然我也只是写了几个比较简单的操作，其中包括双向链
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
Java实现双向链表
03-22
用Java定义一个双向链表，实现链表的基本操作： 初始化、获取头结点、添加新元素、删除链表元素、 获取链表元素、查找链表元素、更新链表中某个元素、 判断链表是否为空、求链表元素个数、输出链表元素、清空链表。
JAVA实现双向链表的增删功能的方法
08-27
在JAVA中，双向链表可以使用类来实现，每个节点是一个对象，包含一个值和两个指针，nextNode和nextNodeF，其中nextNode指向下一个节点，nextNodeF指向上一个节点。 三、链表的创建 在上面的代码中，我们首先创建了...
doublelink.zip_DoubleLink java_双向链表实现
09-24
在本文中，我们将深入探讨如何使用Java编程语言实现一个高效的双向链表数据结构，并通过测试用例进行验证。首先，让我们了解双向链表的基本概念。 双向链表是一种线性数据结构，其中每个节点包含两个指针，分别指向...
java中使用双向链表实现贪吃蛇程序源码分享
09-03
以下是对如何使用Java中的双向链表来构建贪吃蛇程序的详细解释。 首先，我们来看链表节点（SnakeNode）的定义。这个类是链表的基本构建块，它包含了两个整型变量`x`和`y`，分别表示节点在网格中的位置。此外，每个...
双向链表的实现
05-16
自己纯手工实现了用C++写的双向链表，并且有对string操作的例子可供参考
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
双向链表实现
06-14
数据结构小代码，改自 《数据结构与算法分析C++版》 源代码 1.编写使用freelist 的带头、尾结点的双向链表类的定义，实现双向链表的基本操作。 2. 利用双向链表实现2个一元稀疏多项式的加法运算，运算结果得到的链表要求按照指数升序有序，并遍历输出指数升序、指数降序的多项式。
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3143
简述双向链表概念、C语言实现双向链表
[ 数据结构_C实现 ] 双向循环带头链表的简单实现
CSDN博客
03-22 3413
目录 1.双向循环带头链表的介绍。 2.双向循环带头链表的接口。 3.接口实现。 3.1创建新节点 3.2创建返回链表的头结点 3.3打印链表 3.4双向链表查找 3.5双向链表在pos的前面进行插入 3.5.1 头插 3.5.2 尾插 3.6双向链表删除pos位置的节点 3.6.1 尾删 3.6.2 头删 4.菜单 5.完整代码： 6.功能测试： 1.双向循环带头链表的介绍。 所谓双向循环带头链表可以分为以下3类来进行理解： 首先是双向：双向表示后一个节点可以找到
java实现双链表
最新发布
jcc4261的博客
01-31 319
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。LinkedList底层就是一个双向链表，我们来实现一个双向链表。这里多一个尾指针，方便我们对尾插操作从O(n)降到O(1).每个结点多了前驱结点，方便我们对链表进行操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值