Java数据结构中双向链表的实现

更新时间：2022年05月26日 14:10:03 作者：Bro_cat

这篇文章主要介绍了Java数据结构中双向链表的实现,双向链表是一种常见的数据结构,它允许在链表中的任意位置进行高效的插入和删除操作,需要的朋友可以参考下

引言

双向链表（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;
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数据结构中双向链表的实现的文章就介绍到这了,更多相关Java双向链表内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

基于mybatis中test条件中单引号双引号的问题
这篇文章主要介绍了基于mybatis中test条件中单引号双引号的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-01-01
详解Java8 Collect收集Stream的方法
这篇文章主要介绍了Java8-Collect收集Stream的方法，提到了收集器的作用，连接收集器的方法,需要的朋友可以参考下
2018-04-04
IntelliJ IDEA无公网远程Linux服务器环境开发过程(推荐收藏)
下面介绍如何在IDEA中设置远程连接服务器开发环境并结合Cpolar内网穿透工具实现无公网远程连接,然后实现远程Linux环境进行开发，感兴趣的朋友跟随小编一起看看吧
2023-12-12
listview点击无效的处理方法(推荐)
下面小编就为大家带来一篇listview点击无效的处理方法(推荐)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-05-05
Java中对象都是分配在堆上吗？你错了！
这篇文章主要介绍了Java中对象都是分配在堆上吗？你错了！文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，,需要的朋友可以参考下
2019-06-06
细说Springcloud eureka的几种主动下线服务的方式
这篇文章主要介绍了细说Springcloud eureka的几种主动下线服务的方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-09-09
Java给实体每一个字段赋默认值详细代码示例
这篇文章主要给大家介绍了关于Java给实体每一个字段赋默认值的相关资料,在编程过程中有时会出现这样一种情况,在查询无结果时我们需要给实体赋默认值,需要的朋友可以参考下
2023-09-09
Java启动Tomcat的实现步骤
本文主要介绍了Java启动Tomcat的实现步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-05-05
Java编程中10个最佳的异常处理技巧
这篇文章主要介绍了Java编程中10个最佳的异常处理技巧,在本文中,将讨论Java异常处理最佳实践,这些Java最佳实践遵循标准的JDK库,和几个处理错误和异常的开源代码,这还是一个提供给java程序员编写健壮代码的便利手册,需要的朋友可以参考下
2015-01-01
HashMap 和 HashSet的区别
本文主要介绍HashMap 和 HashSet的区别，这里整理了详细的资料来说名两者的区别，并说明如何使用该方法，有需要的小伙伴可以参考下
2016-09-09