Java双向链表知识点详解

一、双链表的基本概念

双链表是链表的一种，每个节点除了存储数据外，还包含两个引用，分别指向前驱节点和后继节点。与单链表相比，双链表可以双向遍历，操作更加灵活。

二、双链表的节点结构

双链表的节点结构包含三个部分：数据域、前驱引用和后继引用。以下是 Java 中双链表节点的典型实现：

class Node {
    int data;       // 数据域
    Node prev;      // 前驱引用
    Node next;      // 后继引用

    public Node(int data) {
        this.data = data;
        prev = null;
        next = null;
    }
}

三、双链表的基本操作

双链表支持多种操作，包括插入、删除、查找等。下面介绍这些操作的实现原理和代码。

1. 插入操作

插入操作可以在链表头部、尾部或中间位置进行。

• 头部插入：将新节点插入到链表的头部。
• 尾部插入：将新节点插入到链表的尾部。
• 中间插入：将新节点插入到指定位置。

以下是插入操作的 Java 代码实现：

public class DoublyLinkedList {
    private Node head;
    private Node tail;
    private int size;

    public DoublyLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    // 头部插入
    public void addFirst(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        size++;
    }

    // 尾部插入
    public void addLast(int data) {
        Node newNode = new Node(data);
        if (tail == null) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.prev = tail;
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }

    // 中间插入
    public void add(int index, int data) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
        if (index == 0) {
            addFirst(data);
        } else if (index == size) {
            addLast(data);
        } else {
            Node current = head;
            for (int i = 0; i < index; i++) {
                current = current.next;
            }
            Node newNode = new Node(data);
            newNode.prev = current.prev;
            newNode.next = current;
            current.prev.next = newNode;
            current.prev = newNode;
            size++;
        }
    }
}

2. 删除操作

删除操作可以删除链表头部、尾部或中间的节点。

• 头部删除：删除链表的第一个节点。
• 尾部删除：删除链表的最后一个节点。
• 中间删除：删除指定位置的节点。

以下是删除操作的 Java 代码实现：

public class DoublyLinkedList {
    // 其他方法保持不变

    // 头部删除
    public int removeFirst() {
        if (head == null) {
            throw new NoSuchElementException();
        }
        int data = head.data;
        head = head.next;
        if (head == null) {
            tail = null;
        } else {
            head.prev = null;
        }
        size--;
        return data;
    }

    // 尾部删除
    public int removeLast() {
        if (tail == null) {
            throw new NoSuchElementException();
        }
        int data = tail.data;
        tail = tail.prev;
        if (tail == null) {
            head = null;
        } else {
            tail.next = null;
        }
        size--;
        return data;
    }

    // 中间删除
    public int remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        if (index == 0) {
            return removeFirst();
        } else if (index == size - 1) {
            return removeLast();
        } else {
            Node current = head;
            for (int i = 0; i < index; i++) {
                current = current.next;
            }
            int data = current.data;
            current.prev.next = current.next;
            current.next.prev = current.prev;
            size--;
            return data;
        }
    }
}

3. 查找操作

查找操作可以根据值或索引查找节点。

• 按索引查找：返回指定索引位置的节点值。
• 按值查找：返回第一个包含指定值的节点索引。

以下是查找操作的 Java 代码实现：

public class DoublyLinkedList {
    // 其他方法保持不变

    // 按索引查找
    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        Node current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.data;
    }

    // 按值查找
    public int indexOf(int data) {
        Node current = head;
        int index = 0;
        while (current != null) {
            if (current.data == data) {
                return index;
            }
            current = current.next;
            index++;
        }
        return -1;
    }
}

四、双链表的遍历

双链表支持双向遍历，可以从头节点开始向后遍历，也可以从尾节点开始向前遍历。

以下是双链表遍历的 Java 代码实现：

public class DoublyLinkedList {
    // 其他方法保持不变

    // 正向遍历
    public void traverseForward() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    // 反向遍历
    public void traverseBackward() {
        Node current = tail;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.prev;
        }
        System.out.println();
    }
}

五、双链表的优缺点

优点

• 支持双向遍历，可以向前或向后访问节点。
• 插入和删除操作效率高，时间复杂度为 O (1)（在已知节点的情况下）。

缺点

• 每个节点需要额外的空间存储前驱引用，内存开销较大。
• 实现相对复杂，需要维护两个引用。

六、双链表的应用场景

双链表适用于需要双向遍历的场景，例如：

• 浏览器的前进后退功能。
• 文本编辑器的撤销和重做功能。
• 操作系统的任务调度队列。

七、Java 集合框架中的双链表

Java 集合框架中的LinkedList类实际上是一个双向链表的实现。以下是LinkedList的基本用法示例：

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();

        // 添加元素
        list.add(1);
        list.add(2);
        list.add(3);

        // 插入元素
        list.addFirst(0);
        list.addLast(4);

        // 遍历元素
        System.out.println("正向遍历:");
        for (int num : list) {
            System.out.print(num + " ");
        }
        System.out.println();

        // 删除元素
        list.removeFirst();
        list.removeLast();

        // 遍历元素
        System.out.println("删除后的遍历:");
        for (int num : list) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

八、总结

双链表是一种灵活的数据结构，支持双向遍历和高效的插入删除操作。在 Java 中，可以通过自定义节点类和链表类来实现双链表，也可以使用 Java 集合框架中的LinkedList类。双链表适用于需要双向遍历的场景，但需要注意其内存开销较大的缺点。