Java数据结构中双向链表的实现
作者：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双向链表内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！