初识数据结构——深入理解LinkedList与链表：吃透LinkedList与链表的终极指南

想不明白的过度思考者2025-04-12 20:23

📌 深入理解LinkedList与链表：从原理到实战应用

🌟 引言

在Java集合框架中，LinkedList和ArrayList是最常用的两种列表结构。它们各有优劣，适用于不同的场景。本文将带你深入探索LinkedList的底层实现------链表，并通过丰富的代码示例和对比分析，帮助你全面掌握其特性和应用场景。

📚 1. ArrayList的缺陷

ArrayList底层基于动态数组 实现，虽然支持高效的随机访问（时间复杂度为O(1)），但在任意位置插入或删除元素时，需要搬移后续元素，导致时间复杂度为O(n)。例如：

java 复制代码 
ArrayList<Integer> list = new ArrayList<>();
list.add(1); // 添加到末尾，O(1)
list.add(0, 0); // 插入到头部，O(n)

缺陷总结：

  • 插入/删除效率低（尤其是头部或中间位置）。
  • 扩容时需要拷贝数据，额外开销大。

🔗 2. 链表：LinkedList的底层结构

2.1 链表的概念

链表是一种物理存储非连续 的数据结构，通过节点的引用（指针）实现逻辑上的连续性。

特点：

  • 节点包含数据域和指针域。
  • 物理上不连续，逻辑上连续。

2.2 链表的分类

链表有多种结构组合，常见的两种：

  1. 无头单向非循环链表 ：结构简单，常用于面试题。

  2. 无头双向循环链表 ：Java中LinkedList的底层实现。

双向链表节点定义：

java 复制代码 
class Node {
    int val;
    Node prev;
    Node next;
}

⚙️ 3. LinkedList的模拟实现

以下是一个简化版的无头单链表实现：

java 复制代码 
/*关于LinkedList的实现练习，只实现String属性*/


//通过这个类来表示一个链表的单链表节点，如果是双链表还需要一个prev
class Node{
    //节点保存的值,为了练习方便把属性设置为public
    public String value;
    //节点的下一个元素
    public Node next;

    //创建构造方法进行初始化
    public Node(String value){
        this.value = value;
        this.next = null;
    }

}

public class MyLinkedList {

    //表示链表的头节点
    //由于此处不考虑傀儡节点，所以当head为空时，表示为一个空链表
    private Node head = null;
    //不像顺序表搞一个size表示有效元素的区间

    //尾插
    public void addLast(String value){
        //如果head为null，直接让它指向新节点
        if(head == null){
            Node newNode = new Node(value);
            head = newNode;
            return;

        }
        //思路：先找到尾巴
        //先把尾巴指向head节点，一直遍历往下找
        Node tail = head;

        for (; tail != null; tail = tail.next){
            if(tail.next == null){
                break;
            }
        }
        //通过上述循环，循环结束之后，此时的tail指向尾巴了
        //此时就创建新的节点，让尾节点的next指向newNode
        Node newNode = new Node(value);
        tail.next = newNode;
        //再把newNode的节点指向null，由于在构造方法中中已经做了这件事，不写也没关系
        newNode.next = null;
    }

    //头插
    public void addFirst(String value){
        //根据刚才value的值，创建一个节点
        Node newNode = new Node(value);
        //把新的节点放到头位置做两件事：
        //1.把新节点的next指向原来的头节点
        newNode.next = head;
        //2.让head指向新节点
        head = newNode;

    }

    //指定位置插入
    public void add(int index, String value){

    }

    //重写toString通过这个方法去遍历链表，构成一个字符串，方便打印
    @Override
    public String toString() {
        //遍历的时候，需要从头结点开始，进行一个元素一个元素的打印
        StringBuilder str = new StringBuilder();
        str.append("[");

        for (Node current = head;current != null;current = current.next){
            if(current.next != null){
                str.append(current.value);
                str.append(",");
            }else {
                str.append(current.value);
            }
        }
        str.append("]");
        return str.toString();
    }

    //----------------------------------------------------------

    public static void test1(MyLinkedList list){
        list.addFirst("A");
        list.addFirst("B");
        list.addFirst("C");
        System.out.println(list);
    }

    public static void test2(MyLinkedList list){
        list.addLast("A");
        list.addLast("B");
        list.addLast("C");
        list.addLast("D");
        list.addLast("E");
        System.out.println(list);
    }

    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        test1(list);
        MyLinkedList list2 = new MyLinkedList();
        test2(list2);
    }
}

以下是一个简化版的双向链表实现：

java 复制代码 
public class MyLinkedList {
    private Node head;
    private Node tail;
    private int size;

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

    // 删除指定值的节点
    public void remove(int key) {
        Node cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    head = head.next;
                    if (head != null) head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) cur.next.prev = cur.prev;
                }
                size--;
                return;
            }
            cur = cur.next;
        }
    }
}

🛠️ 4. LinkedList的使用

4.1 Java集合框架部分：LinkedList继承体系（思维导图）

Iterable Collection List Queue LinkedList Deque AbstractSequentialList AbstractList Serializable Cloneable

4.2 常用方法

4.3 遍历方式

java 复制代码 
// 1. for-each循环
for (int num : list) {
    System.out.print(num + " ");
}

// 2. 迭代器
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    System.out.print(it.next() + " ");
}

// 3. 反向迭代器
Iterator<Integer> rit = list.descendingIterator();
while (rit.hasNext()) {
    System.out.print(rit.next() + " ");
}

🧩 5. 经典链表OJ题解析

5.1 反转链表

题目 ：反转一个单链表。
代码：

java 复制代码 
public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

5.2 判断链表是否有环

快慢指针法：

java 复制代码 
public boolean hasCycle(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) return true;
    }
    return false;
}

📊 6. ArrayList vs LinkedList

对比维度 ArrayList LinkedList
底层结构 动态数组 双向链表
随机访问 O(1) O(n)
头插/删效率 O(n) O(1)
内存占用 连续空间，可能浪费 分散存储，无浪费
适用场景 频繁访问+少量修改 频繁插入/删除

选择建议：

  • 需要快速随机访问？选ArrayList！
  • 频繁在头部或中间插入/删除？选LinkedList！

💡 7.记忆技巧

bash 复制代码 
Iterable是根源，
Collection分三派(List/Queue/Set)，
List有三各不同：
数组实现ArrayList，
链表实现LinkedList，
线程安全Vector顶。

标记接口要记清：
Serializable可序列，
Cloneable能复制，
RandomAccess随机快。

🎯 总结

  • 链表通过节点引用实现逻辑连续，适合频繁修改的场景。
  • LinkedList在Java中基于双向链表实现，提供了高效的插入/删除操作。
  • 理解链表的核心在于掌握指针操作和边界条件处理。

通过本文的学习，相信你对链表和LinkedList有了更深入的理解！快去LeetCode上挑战更多链表题目吧！

💬 互动话题 ：你在项目中用过LinkedList吗？遇到过哪些坑？欢迎评论区分享！

相关推荐
黄雪超1 小时前
JVM——JVM 是如何处理异常的？
java·开发语言·jvm
罗技1234 小时前
ES类的索引轮换
java·linux·elasticsearch
liaokailin5 小时前
Spring AI 实战：第十一章、Spring AI Agent之知行合一
java·人工智能·spring
JANYI20186 小时前
C文件在C++平台编译时的注意事项
java·c语言·c++
王禄DUT6 小时前
高维亚空间超频物质变压缩技术 第27次CCF-CSP计算机软件能力认证
数据结构·算法
benpaodeDD7 小时前
双列集合——map集合和三种遍历方式
java
freyazzr7 小时前
Leetcode刷题 | Day51_图论03_岛屿问题02
数据结构·c++·算法·leetcode·深度优先·图论
Q_Boom8 小时前
前端跨域问题怎么在后端解决
java·前端·后端·spring
搬砖工程师Cola8 小时前
＜Revit二次开发＞ 通过一组模型线构成墙面，并生成墙。Create(Document, IList.Curve., Boolean)
java·前端·javascript
等什么君！8 小时前
学习spring boot-拦截器Interceptor，过滤器Filter
java·spring boot·学习
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05YOLOv8目标检测在RK3588部署全过程06西电B测-计算机网络综合实验(含验收问题)07【2025年最新】OpenWrt 更换国内源的指南（图形界面版)08Coze扣子平台完整体验和实践（附国内和国际版对比）09DeepSeek各版本说明与优缺点分析10yolov10来了！用yolov10训练自己的数据集（原理、训练、部署、应用）