java双向链表

最新推荐文章于 2024-04-13 19:33:20 发布
最新推荐文章于 2024-04-13 19:33:20 发布
阅读量79 收藏
点赞数
分类专栏： javase 文章标签： 链表 java
原文链接：https://zhuanlan.zhihu.com/p/105956446
版权

一 前言

双向链表的简单实现；本篇的实现方式是以方法的形式展现，读者可以将其整合为一个类；

二 双向链表简介

在这里插入图片描述

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

三 双向链表的实现

3.1 定义链表节点
定义data存储数据，知识追寻者使用的时int类型，读者可以改为object类型；
定义前驱节点previous
定义后续节点next

/**
 * @Author lsc
 * <p> 双向链表节点 </p>
 */
public class DoubleNode {

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

3.2 插入头节点
思路如下
将新节点的前驱节点指向nul
新节点的后续节点指向表头
将表头的前驱节点指向新节点

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 插入尾节点
思路如下

表尾的后续节点指向新节点
新节点的前驱节点指向表尾
新节点的后续节点指向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
​ B 节点的后续节点指向 N
N 节点 的前驱节点指向 B
N 节点的后续节点指向 C
C 节点的前驱节点指向 N
重要的也就是要找到B节点的位置，转存C节点；
在这里插入图片描述

/* *
    * @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 删除表头
思路如下
创建一个临时节点,存储表头的后续节点
将临时节点的前驱节点指向null
将临时节点赋值给表头

/* *
    * @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 删除表尾
思路

找到表尾的前驱节点
将表尾的前驱节点的后续节点置为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节点
将 B 节点的后续节点指向 D节点
将D节点前驱节点指向B节点
重要的也就是要找到B节点位置，转存D节点；

在这里插入图片描述

/* *
    * @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
之前我没得选，现在我想做个好人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图解链表 —— JAVA 中的双向链表
AlinaQ05的博客
05-22 4888
1. 双向链表 前面提到了单向链表，单链表的特点是只能从前向后遍历，但是如果我们已知一个节点在链表靠后的位置，这时如果使用单链表效率就会很低，因此引入了双向链表就可以快速的找到靠后的节点。双向链表与单向链表的区别就是它不仅有后继节点，还有前驱节点。这样就既存储了下一个节点的地址，也存储了前一个节点的地址。 2. 双向链表的定义 节点类： class DoubleNode { // 指向前驱节点 DoubleNode prev; // 具体存储的数据
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
【JAVA】双向链表详解
weixin_74999790的博客
06-04 2989
LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。每个数据节点都有两个指针，指向前驱和后继，所以，双向链表中的任意一个节点开始，都可以十分方便找到前驱节点和后继节点。
数据结构 (JAVA)：链表(2)_双向链表（构造、头插、尾插、中间插入、删除等操作及实现代码）
最新发布
2301_80653026的博客
04-13 1134
双向链表在于Link类中，多了一个Pre前驱链接，相对于单链表只有next链接，需要弄清楚前驱和后驱的链接关系可以选择固定headt和last节点，插入或者删除first或者last节点，只需要修改2个链接在链表中间插入链接，需要修改4个链接（第一步一定是把要插入的节点先连接上）；在链表中间删除，只需要修改2个链接，一定要通过画图来更好的理解链接的关系。
Java数据结构--双向链表
m0_74808313的博客
04-23 1460
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
Java实现双向链表
keke的博客
10-07 3773
Java实现双向链表
【Java 数据结构】双向链表
程序猿教你打篮球的博客
11-16 2476
本期主要讲解： 1、什么是双向链表 2、实现一个双向链表 2.1 实现前的约定 2.2 addFirst 方法 2.3 addLast 方法 2.4 addIndex 方法 2.5 contains 方法 2.6 removeAllKey 方法 3、LinkedList 的学习 3.1认识下 LinkedList 3.2 LinkedList 的构造方法 3.3 LinkedList 的遍历 4、ArrayList 和 LinkedList的区别
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
Java双向链表的实现
03-25
自定义的双向链表 博文链接：https://hiliangliang1130-126-com.iteye.com/blog/1144023
java实现双向链表(图解以及分析)
qq_54469537的博客
10-02 1733
详细分析以图解实现双向链表
Java数据结构之双向链表（配图详解，简单易懂）
如风暖阳的博客
01-28 5659
Java数据结构之双向链表（配图详解，简单易懂）
数据结构与算法 第三章：链表 -- 双向链表
天行健 君子以自强不息，地势坤 君子以厚德载物。
12-28 496
1. 双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 ...
【一起学数据结构与算法】Java实现双链表
摸鱼胖嘟嘟的博客
10-01 1384
双链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
一步步带你用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实现双向链表
qq_59599094的博客
01-10 847
【数据结构】—— Java实现双链表
【数据结构】Java实现双向链表
qq_53869058的博客
03-20 1902
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
JAVA 双向链表
10-10
在Java中实现双向链表需要定义一个节点类，节点类中包含一个数据项和两个指针，分别指向前一个节点和后一个节点。下面是一个简单的Java代码示例： ```java class Node { int data; Node prev; Node next; public Node(int data) { this.data = data; this.prev = null; this.next = null; } } class DoublyLinkedList { Node head; public DoublyLinkedList() { this.head = null; } // 在链表头部插入一个节点 public void insertAtHead(int data) { Node newNode = new Node(data); newNode.next = head; if (head != null) { head.prev = newNode; } head = newNode; } // 在链表尾部插入一个节点 public void insertAtTail(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; return; } Node current = head; while (current.next != null) { current = current.next; } current.next = newNode; newNode.prev = current; } // 在指定位置插入一个节点 public void insertAtPosition(int data, int position) { Node newNode = new Node(data); if (head == null || position == 1) { newNode.next = head; if (head != null) { head.prev = newNode; } head = newNode; return; } Node current = head; int currentPosition = 1; while (currentPosition < position - 1 && current.next != null) { current = current.next; currentPosition++; } newNode.next = current.next; newNode.prev = current; current.next = newNode; if (newNode.next != null) { newNode.next.prev = newNode; } } // 从链表中删除一个节点 public void deleteNode(int data) { if (head == null) { return; } Node current = head; while (current != null) { if (current.data == data) { if (current.prev != null) { current.prev.next = current.next; } else { head = current.next; } if (current.next != null) { current.next.prev = current.prev; } return; } current = current.next; } } // 输出链表中的所有节点 public void display() { Node current = head; while (current != null) { System.out.print(current.data + " "); current = current.next; } System.out.println(); } } ``` 然后可以通过以下方式进行测试： ```java public class Main { public static void main(String[] args) { DoublyLinkedList list = new DoublyLinkedList(); list.insertAtHead(3); list.insertAtHead(2); list.insertAtHead(1); list.insertAtTail(4); list.insertAtTail(5); list.insertAtPosition(6, 3); list.display(); // 输出：1 2 6 3 4 5 list.deleteNode(3); list.display(); // 输出：1 2 6 4 5 } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值