Java-双向链表的实现

于 2024-09-10 10:22:48 发布
阅读量481 收藏 6
点赞数 7
分类专栏： 数据结构与算法 文章标签： java 链表 开发语言 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Broken_x/article/details/142090134
版权

引言

        双向链表（Double Linked List）是一种常见的数据结构，它允许在链表中的任意位置进行高效的插入和删除操作。与单向链表不同，双向链表中的每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针。这种结构使得双向链表在某些操作上比单向链表更加灵活和高效。

双向链表的结构

在Java中，双向链表可以通过一个内部类Node来表示链表中的每个节点。每个节点包含三个属性：

  • prev：指向前一个节点的指针。
  • next：指向下一个节点的指针。
  • data：节点存储的数据。
static class Node {
    Node prev; // 指向前一个节点
    Node next; // 指向下一个节点
    int data;  // 节点数据

    public Node(Node prev, Node next, int data) {
        this.prev = prev;
        this.next = next;
        this.data = data;
    }
}

双向链表的初始化

        在双向链表的初始化过程中，我们通常会创建两个哨兵节点（head和tail），它们分别代表链表的头和尾。这两个节点不存储实际数据，仅用于简化链表的操作。

public DoubleLinkedList() {
    head = new Node(null, null, 0);
    tail = new Node(null, null, 0);
    head.next = tail;
    tail.prev = head;
}

双向链表的基本操作

1. 插入操作

双向链表支持在链表的任意位置插入新节点。以下是几个常见的插入操作：

  • 在链表头部插入节点：
public void addfirst(int data) {
    add(0, data);
}
  • 在链表尾部插入节点：
public void addlast(int data) {
    Node prev = tail.prev;
    Node newNode = new Node(prev, tail, data);
    prev.next = newNode;
    tail.prev = newNode;
}
  • 在指定位置插入节点：
public void add(int index, int data) {
    Node prev = findNode(index - 1);
    Node next = prev.next;
    Node newNode = new Node(prev, next, data);
    prev.next = newNode;
    next.prev = newNode;
    if (prev == null) {
        throw illegalIndex(index);
    }
}

2. 删除操作

双向链表同样支持在链表的任意位置删除节点。以下是几个常见的删除操作：

  • 删除链表头部的节点：
public void removefirst() {
    remove(0);
}
  • 删除链表尾部的节点：
public void removelast() {
    Node removeNode = tail.prev;
    Node prev = removeNode.prev;
    prev.next = tail;
    tail.prev = prev;
}
  • 删除指定位置的节点：
public void remove(int index) {
    Node prev = findNode(index - 1);
    Node removeNode = prev.next;
    Node next = removeNode.next;
    prev.next = next;
    next.prev = prev;
    if (prev == null || removeNode == tail) {
        throw illegalIndex(index);
    }
}

3. 查找操作

双向链表可以通过索引查找节点：

public Node findNode(int index) {
    int i = -1;
    for (Node current = head; current != tail; current = current.next, i++) {
        if (i == index) {
            return current;
        }
    }
    return null;
}

4. 遍历操作

双向链表可以通过遍历操作输出链表中的所有节点数据：

public void traverse() {
    Node current = head.next;
    while (current != tail) {
        System.out.println(current.data);
        current = current.next;
    }
}

5.修改操作

根据索引修改节点的的值

public void set(int index, int data) {
    Node node = findNode(index);
    if (node == null || node == tail) {
        throw illegalIndex(index);
    }
    node.data = data;
}

应用场景

双向链表在许多场景中都有广泛的应用，例如：

  • LRU缓存：双向链表可以用于实现LRU（Least Recently Used）缓存算法，通过链表的插入和删除操作来维护缓存中的数据。
  • 浏览器历史记录：浏览器的历史记录可以通过双向链表来实现，用户可以向前或向后导航。
  • 文本编辑器：在文本编辑器中，双向链表可以用于实现光标的移动和文本的插入与删除。

源码 

下面是上面提到的所有源码

package school.doublelinkedlist;


import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * 文件名: null.java
 * 作者: 20526
 * 创建时间: 2024/9/9 17:28
 * 描述:双向链表
 */
public class DoubleLinkedList implements Iterator<Integer> {

    private Node head;//头哨兵节点
    private Node tail;//尾哨兵节点



    public DoubleLinkedList() {
        head = new Node(null, null, 0);
        tail = new Node(null, null, 0);
        head.next = tail;
        tail.prev = head;

    }

    @Override
    public boolean hasNext() {
        Node current = head.next;
        return current!= tail;
    }

       @Override
   public Integer next() {
        Node current = head.next;
       if (!hasNext()) {
           throw new NoSuchElementException();
       }
       int data = current.data;
       current = current.next;
       return data;
   }


    static class Node {
        Node prev;//指向前一个节点
        Node next;//指向下一个节点
        int data;//节点数据

        public Node(Node prev, Node next, int data) {
            this.prev = prev;
            this.next = next;
            this.data = data;
        }
    }

    public Node findNode(int index) {
        int i  =-1;
        for(Node current = head;current!=tail;current=current.next,i++){
            if(i==index){
                return current;
            }
        }
        return null;
    }

    public  void traverse() {
        Node current = head.next;
        while (current != tail) {
            System.out.println(current.data);
            current = current.next;
        }
    }

    public void addfirst(int data) {
        add(0, data);

    }
    public void addlast(int data) {
        Node prev = tail.prev;
        Node newNode = new Node(prev, tail, data);
        prev.next = newNode;

    }
    public void add(int index, int data) {
        Node prev = findNode(index-1);
        Node next = prev.next;
        Node newNode = new Node(prev, next, data);
        prev.next = newNode;
        next.prev = newNode;
        if (prev == null){
            throw illegalIndex(index);
        }

    }

    public void removefirst() {
        remove(0);

    }
    public void removelast() {
        Node removeNode = tail.prev;
        Node prev = removeNode.prev;
        prev.next = tail;
        tail.prev = prev;

    }
    public void remove(int index) {
        Node prev = findNode(index-1);
        Node removeNode = prev.next;
        Node next = removeNode.next;
        prev.next = next;
        next.prev = prev;
        if (prev == null){
            throw illegalIndex(index);
        }

        if (removeNode == tail){
            throw illegalIndex(index);
        }

    }

    public void set(int index, int data) {
        Node node = findNode(index);
        if (node == null || node == tail) {
            throw illegalIndex(index);
        }
        node.data = data;
    }



    private  IllegalArgumentException illegalIndex(int index) {
        throw new IllegalArgumentException(
                String.format("Index: [%d]不合法%n", index));
    }


}

测试类

package school.doublelinkedlist;

import org.junit.Test;

/**
 * 文件名: null.java
 * 作者: 20526
 * 创建时间: 2024/9/9 22:02
 * 描述:
 */
public class DoubleLinkedListTest {

    @Test
    public void test() {
        DoubleLinkedList list = new DoubleLinkedList();
        list.add(0,1);
        list.add(1,2);
        list.add(2,3);
        list.addlast(4);


        list.traverse();



    }
}

总结

        双向链表是一种灵活且高效的数据结构，它通过每个节点中的前后指针，使得在链表中的任意位置进行插入和删除操作变得简单。希望对你有所帮助。

       

 

链表的基本概念以及java实现单链表-循环链表-双向链表
mcrwayfun，欢迎你
07-19 1874
前言 线性结构是非常简单且常用的数据结构，而线性表则是一种非常典型的线性结构。 线性表定义 线性表的数据结构 链表 单链表 单链表的定义 单链表的插入和删除 单链表的遍历，清空，判空，获取指定结点 循环链表 循环链表的定义 循环链表的插入和删除 循环链表的遍历，清空 双向链表 双向链表的定义 双向链表的插入和删除 本节代码传送门，欢迎star：https://github...
java实现环形链表带哨兵
developerFBI的专栏
05-22 198
java实现环形链表带哨兵功能。
Java实现双向链表
03-22
用Java定义一个双向链表，实现链表的基本操作： 初始化、获取头结点、添加新元素、删除链表元素、 获取链表元素、查找链表元素、更新链表中某个元素、 判断链表是否为空、求链表元素个数、输出链表元素、清空链表。
JAVA实现双向链表
热门推荐
冯立彬的博客
04-19 4万+
                                        JAVA实现双向链表其实java.util.LinkedList就是一个双链表：public class DoubleLinkedList{  // 节点类Node  private static class Node  {    Object value;    Node prev = this;   
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
Java算法实例-双向链表操作
08-22
本实例聚焦于Java中的一个重要数据结构——双向链表，它在很多场景下都有着广泛的应用。双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的...
java中使用双向链表实现贪吃蛇程序源码分享
09-03
在Java编程中，双向链表是一种非常有用的结构，它允许数据元素双向链接，可以在两端进行插入和删除操作。在这个特定的场景中，双向链表被用于实现经典的电子游戏——贪吃蛇。以下是对如何使用Java中的双向链表来构建...
(Java)Java双向链表实现(数据结构七)
weixin_30588827的博客
10-11 106
1.迭代器接口实现 package com.zhaochao; public interface Iterator<E> { boolean hasNext(); E next(); boolean delete(); boolean modify(E e); int index(); } 2.异常类实现 ...
【数据结构】Java实现双向链表
qq_53869058的博客
03-20 2161
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
双向链表实现(java)
qq_22993855的博客
09-11 154
双向链表实现(java) java代码实现 package com.bingym.linkedlist.doublelist; public class DoubleLinkedList { //双向链表:既存在一个节点的后向节点next域,同时也存在一个节点的前向节点pre //定义属性:头结点head,不包含任何信息,只是作为一个头结点 private Node head = new Node(0,""); public Node getHead() {
双向链表Java实现
菜菜的博客
01-10 217
双向链表在单项链表的基础上增加了前一个节点的属性。 Node： package linklist1; /** * * @ClassName: Node * @Description: 单向单个链表的节点 * @author xiaomu * @date 2018年1月10日 上午8:24:44 * */ public class Node { private Nod
双向链表的实现（java）
LX__Mr的博客
09-18 189
对于单链表，如果要插入某一个节点或者是删除某一个节点，需要用到一个辅助指针来找到待删除节点的前一个节点，改变它的next域的指向，从而实现删除操作； 对于双向链表，好处即使，双向链表可以实现从后往前的遍历（单链表也可以实现，但是可能会稍微麻烦一点），而且双向链表在删除节点的时候，与单链表的不同之处就在于，它是直接让辅助指针指向待删除的节点，对这个节点的pre域和next域进行修改，从而实现删除操作； 具体实现代码如下：（包含：遍历、在末尾添加、按顺序添加、删除操作） package com.Link; p
【双向链表】java代码实现
m0_58097299的博客
01-22 2745
【双向链表】java代码实现，图文详解，带大家去掌握双向链表知识。
用Java程序6-4双向链表求表元(Java语言描述) 采用双向链表做为线性表的存储结构，编写成员方法:求表元运算。 根据指定的位序号获取元素。 元素不存在时，输出error 输入: 第一行
最新发布
09-22
在Java中，我们可以创建一个双向链表（Doubly Linked List）来实现这个功能。首先，我们需要定义一个Node类来表示链表中的节点，并包含数据域和指向前后节点的引用。然后，可以创建一个DoublyLinkedList类，其中包含一个头节点和相关方法如`getElement(int index)`来进行表元的求解。 ```java // 定义双向链表节点 class Node { int data; Node prev; Node next; public Node(int data) { this.data = data; prev = null; next = null; } } // 双向链表类 public class DoublyLinkedList { private Node head; private Node tail; // 初始化链表为空 public DoublyLinkedList() { head = null; tail = null; } // 添加元素到链表末尾 public void addElement(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; tail = newNode; } else { newNode.prev = tail; tail.next = newNode; tail = newNode; } } // 求表元运算，返回指定索引处的元素 public int getElement(int index) { if (index < 0 || index >= size()) { System.out.println("Error: Index out of range"); return -1; // 返回错误标记 } Node current = head; for (int i = 0; i < index; i++) { current = current.next; } return current.data; // 返回当前节点的数据 } // 获取链表长度 private int size() { int count = 0; Node temp = head; while (temp != null) { count++; temp = temp.next; } return count; } } ``` 使用这个类时，你可以创建一个新的DoublyLinkedList实例，添加元素，然后通过`getElement()`方法获取指定位置的元素： ```java public static void main(String[] args) { DoublyLinkedList dll = new DoublyLinkedList(); dll.addElement(1); dll.addElement(2); dll.addElement(3); int elementAtThree = dll.getElement(2); // 获取索引为2的元素，即3 System.out.println(elementAtThree); // 输出：3 int invalidElement = dll.getElement(5); // 输出：Error: Index out of range } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值