目录

• 引言
• 双向链表的结构
• 双向链表的初始化
• 双向链表的基本操作
• 1. 插入操作
• 2. 删除操作
• 3. 查找操作
• 4. 遍历操作
• 5. 修改操作
• 应用场景
• 源码
• 总结

引言

双向链表（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
 * 创建时间: 2025/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();
    }
}

总结

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