双向链表序列上的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 insert(int data) {
        Node newNode = new Node(data);
        
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
            newNode.prev = current;
        }
    }
    
    // 在链表中删除一个节点
    public void delete(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 print() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();
        
        list.insert(1);
        list.insert(2);
        list.insert(3);
        
        list.print();  // 输出：1 2 3
        
        list.delete(2);
        
        list.print();  // 输出：1 3
    }
}

双向链表在某些场景下具有一些优势，例如：