数据结构-双向链表

双向链表（Double Linked List）是一种复杂且功能强大的数据结构，它允许数据在链表中双向流动。以下是关于双向链表的全面知识点归纳：

一、基本定义与结构

1. 双向链表是链表的一种，它的每个数据结点中都有两个指针，一个指向前一个节点，另一个指向后一个节点。
2. 双向链表的节点通常由三部分组成：指向前一个节点的指针（prev），保存的元素（item），以及指向后一个节点的指针（next）。
3. 在双向链表中，第一个节点的prev指针是null，最后一个节点的next指针也是null。

二、特性与操作

1. 双向性：由于每个节点都有两个指针，因此可以从任意节点向前或向后遍历链表，这提供了更大的灵活性。
2. 操作复杂性：相对于单向链表，双向链表在插入、删除节点时需要处理更多的指针，实现起来稍复杂。
3. 内存占用：由于每个节点都多了一个指针，因此双向链表相对于单向链表会占用更多的内存空间。

三、基本操作

1. 插入节点：可以在链表的开始、结束或特定位置插入新节点，需要更新相应节点的prev和next指针。
2. 删除节点：可以删除链表中的任意节点，同样需要更新相邻节点的prev和next指针。
3. 遍历链表：可以从头节点到尾节点或从尾节点到头节点进行遍历。

四、优点与应用

1. 优点：双向链表提供了更好的功能性和灵活性，可以方便地访问前驱和后继节点。
2. 应用：双向链表常用于需要频繁进行插入、删除和遍历操作的数据结构场景，如文本编辑器中的撤销/重做功能、浏览器的历史记录等。

五、变种结构

1. 双向循环链表：一种特殊的双向链表，其中最后一个节点的next指针指向头节点，形成一个环。这种结构在某些特定应用中可以提高数据访问的效率。

总之，双向链表是一种功能强大且灵活的数据结构，适用于多种应用场景。然而，它也需要更多的内存空间和稍复杂的操作来实现其双向性的优势。

六、代码示例

以下是一个使用Java编写的双向链表（Doubly Linked List）的示例，包括基本的节点类（Node）和双向链表类（DoublyLinkedList）

public class DoublyLinkedList {  
    private Node head;  
    private Node tail;  
  
    // 节点类  
    static class Node {  
        int data;  
        Node prev;  
        Node next;  
  
        Node(int data) {  
            this.data = data;  
            this.prev = null;  
            this.next = null;  
        }  
    }  
  
    // 添加节点到链表尾部  
    public void append(int data) {  
        Node newNode = new Node(data);  
        if (head == null) {  
            head = tail = newNode;  
        } else {  
            tail.next = newNode;  
            newNode.prev = tail;  
            tail = newNode;  
        }  
    }  
  
    // 插入节点到指定位置  
    public void insert(int position, int data) {  
        if (position < 0) {  
            throw new IllegalArgumentException("Position cannot be negative");  
        }  
  
        Node newNode = new Node(data);  
  
        if (position == 0) {  
            if (head == null) {  
                head = tail = newNode;  
            } else {  
                newNode.next = head;  
                head.prev = newNode;  
                head = newNode;  
            }  
        } else {  
            Node current = head;  
            for (int i = 0; i < position - 1 && current != null; i++) {  
                current = current.next;  
            }  
  
            if (current == null) {  
                throw new IndexOutOfBoundsException("Position out of bounds");  
            }  
  
            newNode.next = current.next;  
            if (current.next != null) {  
                current.next.prev = newNode;  
            }  
            current.next = newNode;  
            newNode.prev = current;  
  
            if (newNode.next == null) {  
                tail = newNode;  
            }  
        }  
    }  
  
    // 删除指定数据的节点  
    public void delete(int data) {  
        Node current = head;  
        while (current != null && current.data != data) {  
            current = current.next;  
        }  
  
        if (current == null) {  
            System.out.println("Node not found");  
            return;  
        }  
  
        if (current.prev != null) {  
            current.prev.next = current.next;  
        } else {  
            head = current.next;  
        }  
  
        if (current.next != null) {  
            current.next.prev = current.prev;  
        } else {  
            tail = current.prev;  
        }  
    }  
  
    // 遍历链表并打印数据  
    public void printList() {  
        Node current = head;  
        while (current != null) {  
            System.out.print(current.data + " ");  
            current = current.next;  
        }  
        System.out.println();  
    }  
  
    // 主方法，用于测试  
    public static void main(String[] args) {  
        DoublyLinkedList list = new DoublyLinkedList();  
  
        // 添加节点  
        list.append(1);  
        list.append(2);  
        list.append(3);  
  
        // 插入节点  
        list.insert(1, 1.5);  
  
        // 遍历并打印链表  
        list.printList(); // 输出：1 1.5 2 3  
  
        // 删除节点  
        list.delete(2);  
  
        // 再次遍历并打印链表  
        list.printList(); // 输出：1 1.5 3  
    }  
}