java手撕双向链表（附带源码）-CSDN博客

本文链接：https://blog.csdn.net/m0_61840987/article/details/146041511

Java手撕双向链表 —— 详细项目介绍

1. 项目介绍

1.1 项目背景

在数据结构与算法的学习中，链表作为一种最基本的线性数据结构有着极其重要的作用。链表与数组相比，具有动态扩展、灵活插入和删除的优势。单链表虽然易于理解，但由于其只能沿一个方向遍历，常常导致在某些操作（如向后遍历、删除指定节点等）中效率较低或实现复杂。为此，双向链表（Doubly Linked List）应运而生。

双向链表中，每个节点不仅包含指向下一个节点的引用，还包含指向前一个节点的引用，从而使得链表可以双向遍历。这种数据结构在许多应用场景中都有着重要意义，例如在实现 LRU 缓存、编辑器的撤销/重做操作、浏览器历史记录等方面，双向链表都发挥着关键作用。

本项目旨在从零开始手撕一个双向链表的实现，包括节点类、链表类以及常见操作（如添加、删除、查找、反转、遍历等）。通过该项目，你将深入理解双向链表的内部结构、指针操作和常见算法设计思想，同时掌握如何利用面向对象的设计方法构建一个健壮、易扩展的数据结构。

1.2 项目目标

本项目的主要目标包括：

设计并实现双向链表的数据结构：定义节点类和双向链表类，并实现常见操作方法。
支持泛型数据类型：通过 Java 泛型使双向链表可以存储任意类型的数据，增强通用性。
实现核心操作：
- 在链表头部和尾部插入节点
- 根据索引或指定数据删除节点
- 查找指定数据的节点
- 双向遍历链表，输出节点数据
- 反转链表（双向链表反转较为简单，可展示链表操作的灵活性）
- 获取链表长度及判断链表是否为空
编写详细注释和代码说明：在代码中添加非常详细的注释，便于读者理解每一部分的实现思路和关键逻辑。
项目总结与扩展讨论：分析双向链表在实际应用中的优势、局限和扩展方向，为后续更复杂的数据结构设计提供借鉴。

通过该项目，初学者不仅能够从零开始掌握双向链表的实现原理，还能锻炼自己面向对象设计和数据结构调试的能力，为后续学习和开发更复杂的数据结构（如树、图、哈希表等）打下坚实的基础。

2. 相关知识

在开始实现双向链表之前，我们需要了解一些关键知识点：

2.1 链表的基本概念

链表是一种动态数据结构，由一系列节点组成，每个节点包含数据域和指针域：

单链表：每个节点仅包含一个指向下一个节点的引用，优点在于实现简单，但只能单向遍历。
双向链表：每个节点包含两个指针，一个指向下一个节点，一个指向上一个节点。这样既可以向前遍历，也可以向后遍历，操作更加灵活。

双向链表的主要优点是：

双向遍历：支持从头向尾和从尾向头双向遍历，便于实现删除、插入、查找等操作。
高效插入和删除：在已知节点位置的情况下，无需遍历整个链表即可完成节点的插入和删除操作（时间复杂度 O(1)）。

当然，双向链表也有一些缺点，例如每个节点需要额外存储一个指针引用，从而占用更多内存。

2.2 Java中的对象与引用

Java 是一种面向对象的编程语言，所有对象都通过引用进行访问。在链表实现中，每个节点对象保存对下一个和前一个节点的引用。在操作双向链表时，正确管理这些引用至关重要，必须确保在插入或删除节点时，前后指针都能正确调整，以避免链表断裂或出现悬挂引用。

2.3 面向对象设计原则

在设计数据结构时，应遵循良好的面向对象设计原则，如：

单一职责原则：每个类只应负责单一功能。我们将节点类与链表类分离，节点类仅用于封装数据和指针，链表类负责整体操作管理。
封装性：通过将内部数据（例如头指针、链表长度等）设为私有，暴露公共接口供外部调用，使得链表实现细节对外部透明，增强代码安全性和可维护性。

2.4 泛型与集合

利用 Java 泛型，我们可以使链表类支持存储任意类型的数据。泛型的使用不仅提高了代码复用性，还能在编译时检查类型安全，避免强制类型转换带来的风险。

2.5 常见操作与算法

在双向链表中，常见的操作包括：

插入操作：包括在链表头部插入、在链表尾部插入和在指定位置插入节点。
删除操作：根据节点数据或索引删除节点，删除时需要同时更新前驱和后继指针。
遍历操作：双向遍历链表，输出每个节点的数据，验证链表的正确性。
反转操作：对双向链表进行反转操作，使得链表顺序颠倒，考察指针反转的技巧。
查找操作：遍历链表查找是否存在指定数据。

通过理解以上操作，你可以全面掌握双向链表的实现原理，并在代码中灵活应用这些算法。

3. 项目实现思路

本项目实现双向链表的主要实现思路如下：

3.1 节点类设计

设计一个内部类 Node，用于表示双向链表的节点。每个节点包含以下成员变量：

data：存储数据，可以是任意类型（使用泛型 T）。
prev：指向前一个节点的引用。
next：指向下一个节点的引用。

节点类应提供构造方法，用于初始化节点数据和指针，并提供简单的 getter 方法以便访问数据。

3.2 双向链表类设计

设计一个双向链表类（例如 MyDoublyLinkedList），主要包括以下成员变量：

head：指向链表第一个节点的引用。
tail：指向链表最后一个节点的引用，便于在链表尾部插入节点时直接操作。
size：记录链表中的节点数量。

主要方法设计：

add(T data)：在链表尾部添加节点。
- 若链表为空，则新节点同时作为 head 和 tail；
- 若链表非空，则将新节点添加到 tail 后，并更新 tail 指针。
addFirst(T data)：在链表头部添加节点。
- 将新节点插入到 head 前面，并更新 head 指针。
remove(T data)：根据数据删除第一个匹配的节点。
- 遍历链表找到目标节点，根据其在链表中的位置调整前后节点指针，并更新 head 或 tail 指针（如果删除的是头尾节点）。
removeAt(int index)：根据索引删除节点。
- 根据索引遍历链表找到目标节点，执行删除操作，并更新链表长度，同时处理头尾情况。
contains(T data)：判断链表是否包含某个数据，遍历链表返回布尔结果。
get(int index)：根据索引返回节点数据，遍历链表直到指定位置。
reverse()：反转链表。
- 遍历链表，将每个节点的 prev 和 next 指针交换，最后交换 head 和 tail 指针。
print()：遍历链表从头到尾输出所有节点数据，便于验证链表状态。

3.3 异常处理

在实现过程中，需要考虑以下异常情况：

索引越界：当用户调用 get() 或 removeAt() 方法时，需检查索引是否合法，若不合法则抛出异常。
空链表处理：在执行删除操作时，需要检查链表是否为空，避免出现 NullPointerException。
重复数据处理：在 remove(T data) 方法中，通常只删除第一个匹配的节点。

3.4 测试与调试

在主方法中，构造一组测试用例，对双向链表的各项操作进行验证。测试内容包括：

在链表尾部和头部插入数据；
遍历链表输出当前数据；
根据数据和索引删除节点；
查找链表中是否存在指定数据；
反转链表，验证遍历结果；
打印链表大小，确保链表长度更新正确。

通过全面的测试与调试，保证各个方法的正确实现和链表整体结构的稳定性。

3.5 扩展思路

在基础实现的基础上，可以进一步扩展功能：

实现 Iterable 接口：使得双向链表支持 foreach 循环遍历。
排序功能：实现双向链表排序算法，如归并排序，适合链表结构。
其他操作：例如查找中间节点、删除所有指定数据节点等。

通过以上设计思路，我们能够全面掌握双向链表的实现原理，并为实际项目中需要动态数据存储和处理的数据结构提供借鉴。

4. 完整代码示例

下面是完整代码示例。所有代码整合在一起，包含节点类和双向链表类的实现，以及主方法测试。代码中附有非常详细的注释，便于读者逐行理解实现细节。

/**
 * MyDoublyLinkedList.java
 *
 * 本程序实现了一个双向链表（Doubly Linked List），支持泛型数据存储。
 * 实现功能包括：在链表头部和尾部添加节点、删除节点、查找节点、反转链表、遍历链表输出数据等。
 *
 * 该实现采用面向对象设计思想，将节点类（Node）和链表类（MyDoublyLinkedList）分离，
 * 保证代码结构清晰、易于维护与扩展。代码中附有详细注释，逐步讲解每个方法的实现原理和操作逻辑。
 */
public class MyDoublyLinkedList<T> {

    /**
     * 节点类，表示双向链表中的节点。
     * 每个节点包含存储数据的域 data，以及指向前一个节点的 prev 和指向后一个节点的 next。
     */
    private static class Node<T> {
        T data;         // 存储节点的数据
        Node<T> prev;   // 指向前一个节点
        Node<T> next;   // 指向后一个节点

        /**
         * 构造方法，初始化节点数据，同时将 prev 和 next 指针设置为 null
         * @param data 节点中存储的数据
         */
        Node(T data) {
            this.data = data;
            this.prev = null;
            this.next = null;
        }
    }

    private Node<T> head; // 头节点引用
    private Node<T> tail; // 尾节点引用
    private int size;     // 链表中节点的个数

    /**
     * 构造方法，初始化一个空的双向链表。
     */
    public MyDoublyLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    /**
     * 在链表尾部添加新节点
     *
     * @param data 要添加的数据
     */
    public void add(T data) {
        Node<T> newNode = new Node<>(data);
        // 如果链表为空，新节点成为头和尾
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            // 将新节点添加到链表尾部，调整前驱和后继指针
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
        size++;
    }

    /**
     * 在链表头部添加新节点
     *
     * @param data 要添加的数据
     */
    public void addFirst(T data) {
        Node<T> newNode = new Node<>(data);
        // 如果链表为空，新节点成为头和尾
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            // 将新节点插入到链表头部
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        size++;
    }

    /**
     * 根据数据删除第一个匹配的节点
     *
     * @param data 要删除的节点数据
     * @return true 表示删除成功，否则 false
     */
    public boolean remove(T data) {
        if (head == null) return false; // 空链表
        // 如果头节点数据匹配
        if (head.data.equals(data)) {
            head = head.next;
            if (head != null) {
                head.prev = null;
            } else {
                // 链表变空时，更新尾节点
                tail = null;
            }
            size--;
            return true;
        }
        Node<T> current = head;
        // 遍历查找匹配节点
        while (current != null) {
            if (current.data.equals(data)) {
                // 调整前后节点引用
                if (current.next != null) {
                    current.next.prev = current.prev;
                } else {
                    // 删除尾节点时更新 tail
                    tail = current.prev;
                }
                if (current.prev != null) {
                    current.prev.next = current.next;
                }
                size--;
                return true;
            }
            current = current.next;
        }
        return false;
    }

    /**
     * 根据索引删除节点
     *
     * @param index 要删除节点的位置（从0开始）
     * @return 删除节点的数据
     * @throws IndexOutOfBoundsException 如果索引无效
     */
    public T removeAt(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
        Node<T> current = head;
        if (index == 0) {
            T data = head.data;
            head = head.next;
            if (head != null) {
                head.prev = null;
            } else {
                tail = null;
            }
            size--;
            return data;
        }
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        // 调整前后节点引用
        if (current.prev != null) {
            current.prev.next = current.next;
        }
        if (current.next != null) {
            current.next.prev = current.prev;
        } else {
            // 如果删除的是尾节点，更新 tail
            tail = current.prev;
        }
        size--;
        return current.data;
    }

    /**
     * 根据索引获取节点数据
     *
     * @param index 节点索引（从0开始）
     * @return 节点中的数据
     * @throws IndexOutOfBoundsException 如果索引越界
     */
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
        Node<T> current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.data;
    }

    /**
     * 判断链表是否包含指定数据
     *
     * @param data 要查找的数据
     * @return true 表示包含，否则 false
     */
    public boolean contains(T data) {
        Node<T> current = head;
        while (current != null) {
            if (current.data.equals(data)) return true;
            current = current.next;
        }
        return false;
    }

    /**
     * 返回链表中节点的个数
     *
     * @return 链表长度
     */
    public int size() {
        return size;
    }

    /**
     * 遍历链表并打印所有节点数据
     */
    public void print() {
        Node<T> current = head;
        System.out.print("双向链表内容：");
        while (current != null) {
            System.out.print(current.data + " <-> ");
            current = current.next;
        }
        System.out.println("null");
    }

    /**
     * 反转双向链表
     *
     * 该方法遍历链表，将每个节点的 prev 和 next 指针互换，
     * 最后更新头和尾节点，返回反转后的链表头节点。
     *
     * @return 反转后的头节点
     */
    public Node<T> reverse() {
        Node<T> current = head;
        Node<T> temp = null;
        // 交换每个节点的 prev 和 next
        while (current != null) {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            // 移动到下一个节点（原先的 prev）
            current = current.prev;
        }
        // 如果链表不为空，更新头节点
        if (temp != null) {
            head = temp.prev;
        }
        return head;
    }

    /**
     * 主函数，用于测试双向链表的各项功能
     */
    public static void main(String[] args) {
        // 创建一个空的双向链表，数据类型为 Integer
        MyDoublyLinkedList<Integer> list = new MyDoublyLinkedList<>();
        System.out.println("初始链表大小：" + list.size());
        
        // 测试在链表尾部添加节点
        list.add(10);
        list.add(20);
        list.add(30);
        list.print();
        System.out.println("链表大小：" + list.size());

        // 测试在链表头部添加节点
        list.addFirst(5);
        list.print();
        System.out.println("链表大小：" + list.size());

        // 测试删除指定数据的节点
        boolean removed = list.remove(20);
        System.out.println("删除20：" + (removed ? "成功" : "失败"));
        list.print();
        System.out.println("链表大小：" + list.size());

        // 测试根据索引删除节点
        int removedData = list.removeAt(1);
        System.out.println("删除索引1的节点数据：" + removedData);
        list.print();
        System.out.println("链表大小：" + list.size());

        // 测试反转链表
        System.out.println("反转链表：");
        list.reverse();
        list.print();
    }
}

5. 代码解读

以下对代码中主要方法的用途进行说明：

Node 类
该内部类用于表示双向链表中的单个节点。每个节点包含存储数据的成员变量 data 以及两个指针 prev（指向前一个节点）和 next（指向后一个节点）。构造方法用于初始化数据并将指针设为 null。
构造方法 MyDoublyLinkedList()
初始化一个空的双向链表，将头节点和尾节点都设置为 null，同时链表大小设为 0。
add(T data) 方法
在链表尾部添加一个新节点。该方法判断链表是否为空，若为空则新节点即为头和尾；若不为空，则将新节点添加到尾部，并更新尾指针，最后增加链表大小。
addFirst(T data) 方法
在链表头部添加一个新节点。该方法将新节点的 next 指针指向当前头节点，并更新头节点为新节点。如果链表为空，新节点同时作为头和尾；并更新链表大小。
remove(T data) 方法
根据给定数据删除链表中第一个匹配的节点。方法遍历链表，若头节点匹配则直接更新头指针；否则找到匹配节点后，调整前后节点的指针链接，更新链表大小，并返回删除结果。
removeAt(int index) 方法
根据索引删除节点。方法首先验证索引是否有效，然后遍历链表到指定位置，删除对应节点，并调整前后指针。如果删除的是头或尾节点，则相应更新头和尾指针，返回被删除节点的数据。
get(int index) 方法
根据索引返回链表中对应位置的节点数据。该方法遍历链表直至找到目标节点，若索引无效则抛出异常。
contains(T data) 方法
遍历链表，判断链表中是否包含指定数据，返回布尔值表示查找结果。
size() 方法
返回链表中节点的总数。
print() 方法
遍历链表，并将每个节点的数据以 “data <-> ” 的形式打印输出，直至链表结束，便于调试和展示链表结构。
reverse() 方法
反转整个双向链表。该方法遍历链表，将每个节点的 prev 和 next 指针交换，并在遍历结束后更新头节点为原尾节点，从而实现链表的反转。
main() 方法
用于测试双向链表的各项功能。方法中先构造一个空链表，随后测试添加节点、在头部插入节点、删除指定数据、根据索引删除节点、反转链表等操作，并输出每一步操作后的链表状态，以验证所有功能是否正确实现。

6. 项目总结

6.1 项目意义

双向链表作为一种基础而又常用的数据结构，不仅在理论学习中占据重要地位，也是许多高级数据结构（如 LRU 缓存、双向队列）的基础。通过手撕双向链表，你可以深入理解动态内存分配、指针操作及链表基本算法。该项目的意义主要包括：

巩固数据结构基础：通过手动实现双向链表，熟悉链表节点的构造、内存链接和指针操作，为学习更复杂的数据结构打下基础。
提升面向对象编程能力：项目中将节点类与链表类分离，采用泛型实现，使得代码结构清晰，易于维护和扩展。
实践算法实现：实现常见操作（如添加、删除、查找、反转、遍历）有助于提升算法实现能力，培养对边界情况的敏感性和调试能力。
为实际项目提供基础：在实际开发中，许多业务场景需要灵活的数据结构支持，双向链表作为基础结构，可以为队列、缓存、动态列表等模块提供数据支撑。

6.2 项目实现回顾

本文从项目背景出发，详细介绍了双向链表的基本概念、相关知识和设计思路。实现过程中主要包括以下几个部分：

节点类设计：
定义了一个内部类 Node，用于表示双向链表中的单个节点，每个节点包含数据和前后指针，构造方法用于初始化节点数据。
双向链表类设计：
设计了 MyDoublyLinkedList 类，包含头指针、尾指针和链表长度三个核心成员变量。实现了添加节点（在头部和尾部）、删除节点（按数据和按索引）、查找节点、判断包含、获取长度、遍历输出以及反转链表等常见操作。
详细注释：
在代码中对每个方法的实现细节和关键操作均添加了详细注释，便于初学者理解双向链表的实现原理和设计思路。
测试与调试：
主方法中构造了一系列测试用例，依次验证了添加、删除、查找、反转等操作的正确性。通过打印链表状态展示了每个操作后的链表结构，确保所有方法均按照预期工作。
扩展讨论：
最后，讨论了如何在未来对项目进行扩展，如实现双向链表排序、支持 Iterable 接口、批量数据处理以及更复杂的异常处理等，为实际项目应用提供借鉴。