java 双向链表_java实现双向链表

最新推荐文章于 2022-07-05 20:43:59 发布
最新推荐文章于 2022-07-05 20:43:59 发布
阅读量148 收藏
点赞数
文章标签： java 双向链表 java 链表 java链表

一 前言

之前知识知识追寻者写了一篇单链表的实现，感觉不是很满意，写的逻辑不够清晰，有些地方实现的不过好，不能连成一个整体，伪单链表；为此研究了一会双向链表的简单实现；本篇的实现方式是以方法的形式展现，读者可以将其整合为一个类；

二 双向链表简介

双向链表的定义是，一个节点有两个方向，分别储存当前节点的前驱节点，和后续节点；双向链表的删除只需要指定前驱节点，或者后续节点就可以进行删除操作；但是缺点也很明显每次添加节点时都需要2个指向，额外增加了内存空间消耗；

c3dacb884f69da55bbfcd7adb0155117.png

三 双向链表的实现

3.1 定义链表节点

  1. 定义data存储数据，知识追寻者使用的时int类型，读者可以改为object类型；
  2. 定义前驱节点previous
  3. 定义后续节点next
/**
 * @Author lsc
 * <p> 双向链表节点 </p>
 */
public class DoubleNode {

    //数据
    private Integer data;
    //后续节点节点
    private DoubleNode next;
    //前驱节点
    private DoubleNode previous;
    // 省略set get
}

3.2 插入头节点

思路如下

  1. 将新节点的前驱节点指向nul
  2. 新节点的后续节点指向表头
  3. 将表头的前驱节点指向新节点
public class DoubleList {

    private DoubleNode head;

    /* *
     * @Author lsc
     * <p> 表头插入节点
     *  思路： 1 将新节点的前驱节点指向null，
     *        2新节点的后续节点指向表头
     *        3 将表头的前驱节点指向新节点
     * </p>
     * @Param [data]
     * @Return void
     */
   public void addFirst(int data){
       // 创建新节点
       DoubleNode newNode = new DoubleNode();
       // 为新节点添加数据
       newNode.setData(data);
       // 如果表头为空直接将新节点作为头
       if (head==null){
           head = newNode;
       }else {
           // 将新节点的前驱节点指向null(声明的时候本来就是null)
           //新节点的后续节点指向表头
           newNode.setNext(head);
           // 将表头的前驱节点指向新节点
           head.setPrevious(newNode);
           // head重新赋值
           head = newNode;
       }
   }
     /* *
     * @Author lsc
     * <p>顺序打印链表
      思路：从链表的头遍历到链表的尾巴
     * </p>
     * @Param []
     * @Return void
     */
   public void displayNext(){
       // 将表头作为当前节点
       DoubleNode currentNode = head;
       // 遍历链表
       while (currentNode!=null){
           // 打印数据
           System.out.println(currentNode.getData());
           // 将下一个节点作为当前节点
           currentNode = currentNode.getNext();
       }
   }
}

测试代码如下，往前插入数据，打印出来就是倒序

public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        for (int i = 0; i <5 ; i++) {
            doubleList.addFirst(i);
        }
        doubleList.displayNext();
    }

结果

4
3
2
1
0

3.3 插入尾节点

思路如下

  1. 表尾的后续节点指向新节点
  2. 新节点的前驱节点指向表尾
  3. 新节点的后续节点指向null
/* *
     * @Author lsc
     * <p> 表尾插入节点
     * 思路 ： 1 表尾的后续节点指向新节点
     *        2 新节点的前驱节点指向表尾
     *        3 新节点的后续节点指向null
     * </p>
     * @Param [data]
     * @Return void
     */
   public void addLast(int data){
       // 创建新节点
       DoubleNode newNode = new DoubleNode();
       // 为新节点添加数据
       newNode.setData(data);
       // 如果表头为空直接将新节点作为头
       if (head==null){
           head = newNode;
       }else {
           DoubleNode currentNode = head;
           //寻找尾节点
           while (currentNode.getNext()!=null){
               currentNode = currentNode.getNext();
           }
           //表尾的后续节点指向新节点
           currentNode.setNext(newNode);
           //新节点的前驱节点指向表尾
           newNode.setPrevious(currentNode);
       }
   }

测试代码如下，往表为插入数据，也就是顺序打印

public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        for (int i = 0; i <5 ; i++) {
            //doubleList.addFirst(i);
            doubleList.addLast(i);
        }
        doubleList.displayNext();
    }

结果

0
1
2
3
4

3.4 获取链表长度

思路 ：遍历链表，一个节点代表一个单位的长度

/* *
     * @Author lsc
     * <p> 获得链表长度
     * 思路：遍历链表，一个节点代表一个单位的长度
     *  </p>
     * @Param []
     * @Return int
     */
   public int length(){
       int length = 0;
       // 当前节点
       DoubleNode currentNode = head;
       while (currentNode!=null){
           // 一个节点 length 长度就加1
            length++;
            // 将下一个节点作为当前节点
            currentNode = currentNode.getNext();
       }
       return length;
   }

3.5 指定位置插入节点

思路： 假设在BC直接插入新节点N

  1. ​ B 节点的后续节点指向 N
  2. N 节点 的前驱节点指向 B
  3. N 节点的后续节点指向 C
  4. C 节点的前驱节点指向 N

重要的也就是要找到B节点的位置，转存C节点；

c0162bda1bd2e756ee3e03846e3f8ac3.png 
/* *
    * @Author lsc
    * <p> 指定位置插入节点
    * 思路： 假设在AB直接插入新节点N
    *       1 A 节点的后续节点指向 N
    *       2 N 节点 的前驱节点指向 A
    *       3 N 节点的后续节点指向 B
    *       4 B 节点的前驱节点指向 N
    * 重点也是找到A节点的位置
    *  </p>
    * @Param [data]
    * @Return void
    */
   public void add(int data, int index){
       // 索引超出，非法
       if (index<0 || index>length()){
           System.out.println("非法索引");
           return;
       }
       // 如果索引为0，调用addFirst方法
       if (index==0){
           addFirst(data);
           return;
       }
       // 如果索引等于链表的长度，调用addLast方法
       if (index==length()){
           addLast(data);
           return;
       }
       // 创建新节点
       DoubleNode newNode = new DoubleNode();
       // 为新节点添加数据
       newNode.setData(data);
       // 当前节点
       DoubleNode currentNode = head;
       // 定义指针
       int point = 0;
       // 寻找插入新节点的上一个节点A
       while ((index-1)!= point){
           currentNode = currentNode.getNext();
           point++;
       }
       // 转存当前节点的后续节点
       DoubleNode nextNode = currentNode.getNext();
       // 当前节点的后续节点指向新节点
       currentNode.setNext(newNode);
       // 新接的前驱节点指向当前节点
       newNode.setPrevious(currentNode);
       // 新节点的后续节点指向转存的节点
       newNode.setNext(nextNode);
       // 转存节点的前驱节点指向新节点
       nextNode.setPrevious(newNode);

   }

测试代码

public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        for (int i = 0; i <5 ; i++) {
            doubleList.addLast(i);
        }
        doubleList.add(666,3);
        doubleList.displayNext();
    }

结果

0
1
2
666
3
4

3.6 删除表头

思路如下

  1. 创建一个临时节点,存储表头的后续节点
  2. 将临时节点的前驱节点指向null
  3. 将临时节点赋值给表头
/* *
    * @Author lsc
    * <p> 删除表头
     思路： 1 创建一个临时节点,存储表头的后续节点
     *     2 将临时节点的前驱节点指向null
     *     3 将临时节点赋值给表头
    * </p>
    * @Param []
    * @Return void
    */
   public void removeFirst(){
       if (length()==0){
           return;
       }
       // 只有一个节点直接清空表头
       if (length()==1){
           head=null;
           return;
       }
       // 创建一个临时节点,存储表头的后续节点
       DoubleNode temNode = head.getNext();
       // 将临时节点的前驱节点指向null
       temNode.setPrevious(null);
       // 将临时节点赋值给表头
       head = temNode;
   }

测试代码

public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        for (int i = 0; i <5 ; i++) {
            doubleList.addLast(i);
        }
        doubleList.removeFirst();
        doubleList.displayNext();
    }

结果

1
2
3
4

3.7 删除表尾

思路

  1. 找到表尾的前驱节点
  2. 将表尾的前驱节点的后续节点置为null
/* *
    * @Author lsc
    * <p> 删除表尾
        思路： 1 找到表尾的前驱节点
        *     2 将表尾的前驱节点的后续节点置为null
        *     3
    * </p>
    * @Param []
    * @Return void
    */
   public void removeLast(){
        if (length()==0){
            return;
        }
       // 只有一个节点直接清空表头
       if (length()==1){
           head=null;
           return;
       }
       DoubleNode previousNode = head;
       // 寻找尾节点的前驱节点
       while (previousNode.getNext().getNext()!=null){
           previousNode = previousNode.getNext();
       }
       previousNode.setNext(null);
   }

测试代码

public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        for (int i = 0; i <5 ; i++) {
            //doubleList.addFirst(i);
            doubleList.addLast(i);
        }
        doubleList.removeLast();
        doubleList.displayNext();
    }

结果

0
1
2
3

3.8 删除指定节点

思路： 假设有BCD节点要删除B节点

  1. 将 B 节点的后续节点指向 D节点
  2. 将D节点前驱节点指向B节点

重要的也就是要找到B节点位置，转存D节点；

be65fa54ca8a1215ce286c2b6c7b917c.png 
/* *
    * @Author lsc
    * <p>  指定位置删除节点
      思路： 假设有ABC节点要删除B节点
      *     1 将 A 节点的后续节点指向 C节点
      *     2 将C节点前驱节点指向A节点
    * </p>
    * @Param [index]
    * @Return void
    */
   public void remove(int index){
       if (index<0 || index>=length()){
           System.out.println("非法索引");
           return;
       }
       // 头节点
       if (index==0){
           removeFirst();
           return;
       }
       // 尾节点
       if (index==(length()-1)){
           removeLast();
           return;
       }
       // 欲想删除节点的前驱节点
       DoubleNode previousNode = head;
       // 定义指针
       int point = 0;
       // 寻找新节
       while ((index-1)!=point){
           previousNode = previousNode.getNext();
           point++;
       }
       // 欲想删除节点的后续节点
       DoubleNode nextNode = previousNode.getNext().getNext();
       // 将欲想删除节点的前驱节点的后续节点指向欲想删除节点的后续节点
       previousNode.setNext(nextNode);
       // 将欲想删除节点的后续节点的前驱节点指向欲想删除节点的前驱节点
       nextNode.setPrevious(previousNode);

   }

测试代码

public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        for (int i = 0; i <5 ; i++) {
            //doubleList.addFirst(i);
            doubleList.addLast(i);
        }
        doubleList.remove(3);
        doubleList.displayNext();
    }

结果

0
1
2
4
weixin_39639505
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
双向链表（java实现）
04-09
NULL 博文链接：https://128kj.iteye.com/blog/1643350
双向链表（Java）
weixin_46360473的博客
03-13 410
双向链表（Java） 双向链表:也叫双链表，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 双向链表的结构特点如下： 较单链表相比优势： 插入删除不需要移动元素，可以自我删除 可双向遍历 代码如下： public class Doubleloop { Doubleloop prior=this;//上...
Java--双向链表
RuanMeng的博客
07-29 85
双向链表也是链表的一种，特殊性在于：它对比单链表多了一个指向前驱(prev)的引用。 注意：head----指向链表的第一个结点 last------指向链表最后一个结点 size------当前链表结点个数 class Node { int val; Node next = null; // 指向后继结点，最后一个结点的 next == null Node ...
java双向链表
CherishL_的专栏
08-08 457
既允许向前遍历也允许向后遍历整个链表 public class Link { public long dData; public Link next; public Link previous; public Link(long d){ dData=d; } public void displayLink(){ Syste
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
doublelink.zip_DoubleLink java_双向链表实现
09-24
使用java语言实现双向链表，提供测试用例说明功能
Java实现双向链表
03-22
用Java定义一个双向链表，实现链表的基本操作： 初始化、获取头结点、添加新元素、删除链表元素、 获取链表元素、查找链表元素、更新链表中某个元素、 判断链表是否为空、求链表元素个数、输出链表元素、清空链表。
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
java双向循环链表的实现代码
09-05
介绍了java双向循环链表的实现代码，有需要的朋友可以参考一下
Java--双向链表（1）
sunjiac的博客
11-07 120
双向链表 1.建立链表 ①.节点类 ②.链表类 class ListNode{ public int data; public ListNode prev;//前驱 public ListNode next;//后继 public ListNode(int data) { this.data = data; } } public clas...
Java 实现 双向链表
m0_52066789的博客
01-06 3782
在上篇文章中介绍了怎么使用 java 代码编写一个自己的单链表，那么接下来就又来介绍下双链表的实现。 Java代码实现单链表：Java实现 单链表_m0_52066789的博客-CSDN博客 目录 1.双链表 1.1 双链表的基本框架 1.2 头节点实体类（ListNode） 1.3 双向链表实体类（DoubleLinkedList） 1.3.1 头插法 — addFirst（int data） 1.3.2 尾插法 —addLast（int data） 1.3.3 根据下标插入新的节..
线性表（四）——链表——双向链表
weixin_43328054的博客
02-15 207
概念 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个节点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一指针域用来指向其前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域为null，指向后继结点的指针域指向第一个真正存储数据的结点。 具体实现 package linear; import java.util.Iterator; public class TwoWayLinklist<T> implements Iterable
Java数据结构之双向链表
qq15035899256的博客
07-05 1772
双向遍历，既可以从前向后遍历，也可以从后往前遍历。(工作中常用) 优点：可以找到前驱和后继，可进可退；缺点：增加删除节点复杂，需要多分配一个指针存储空间。
java中的双向链表
you_never_alone的博客
05-05 278
为了使得链表可以找到他的前驱，我们基于单链表设定了双向链表，在next的基础上加了prio前驱用来指向节点前驱，让我们来了解一下。初始化class Entry{ int data; Entry next; Entry prio; public Entry(){ this.data =-1; this.next =null; this.prio = null;...
JAVA双向链表
qq_23858785的博客
04-19 6076
JAVA双向链表操作 双向链表的每一个结点都有一条指向其后继结点的next指针和一条指向其前结点的pre指针。 双向链表的插入图示： 双向链表的删除图示： import java.io.IOException; import java.util.Scanner; class Node{ public int data;//数据域 public Node next;//后继指针域 public Node previous;//前驱指针域 public Node(int
双向链表-java
weixin_45065377的博客
05-27 88
代码实现： package com.cxq.linkedlist; public class DoubleLinkedListDemo { public static void main(String[] args){ DoubleLinkedList doubleLinkedList = new DoubleLinkedList(); doubleLinkedList.add(new HeroNode2(4, "林冲", "豹子头")); // ..
java创建双向链表_Java双向链表创建/输出---基础<Base>：
最新发布
05-18
在Java中，我们可以使用类来实现双向链表。 下面是一个简单的Java程序，演示如何创建和输出双向链表： ```java // 双向链表节点类 class Node { public int data; public Node prev; public Node next; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值