[数据结构] LinkedList

原创 已于 2025-09-13 13:48:23 修改 · 1k 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

于 2025-09-06 13:54:37 首次发布

1. 什么是 LinkedList

  LinkedList (官方文档)

LinkedList是Java集合框架中的一个双向链表实现，位于java.util包中。它实现了List和Deque接口，支持高效的插入和删除操作，但随机访问性能较差

2. LinkedList 的 特性

  • 双向链表结构：每个节点（Node）包含前驱（prev）、后继（next）和当前元素（item）的引用
  • 非连续内存存储：与ArrayList不同，LinkedList的元素在内存中不连续存储
  • 动态大小：无需预先分配空间，大小随元素增减动态变化

3. LinkedList 实现的接口

  • LinkedList 实现了 List 接口
  • LinkedList 的底层是使用了双向链表
  • LinkedList 没有实现 RandomAccess 接口 , 因此 LinkedList 不支持随机访问
  • LinkedList 的任意插入和删除元素时效率比较高效 , 时间复杂度为O(1)
  • LinkedList 比较适合任意位置插入的场景

4. LinkedList 的使用

4.1 LinkedList 的创建

① LinkedList 的创建

    public static void main(String[] args) {
        List<Integer> list1 = new LinkedList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        System.out.println(list1);
    }

② 用 ArrayList 来构造 LinkedList

    public static void main(String[] args) {
        List<Integer> list2 = new java.util.ArrayList<>();
        list2.add(22);
        list2.add(122);
        list2.add(233);
        list2.add(344);
        System.out.println(list2);
        List<Integer> list3 = new LinkedList<>(list2);
    }

4.2 LinkedList 常用方法的介绍

方法解释
 boolean add (E e)尾插 e
void add (int index , E element)将 e 插入到 index 位置
boolean addAll (Collection<? extends E> c)尾插 c 中的元素
E remove (int index)删除 index 位置的元素
boolead remove (Object o)删除遇到的第一个元素 o
E get (int index)获取下标 index 的元素
E set (int index , E element)将下标 index 位置的元素设置为 element
void clear ()清空
boolean contains (Object o)判断 o 是否包含在线性表中
int indexOf (Object o)返回第一个 o 所在位置的下标
int lastindexOf (Object o)返回最后一个 o 所在位置的下标
List<E> subList (int fromIndex , int toIndex)截取部分 list

部分方法演示

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(44);
        list.add(99);
        list.add(22);
        System.out.println(list);//[11, 22, 33, 44, 99, 22]

        list.add(0,88);//指定位置插入
        System.out.println(list);//[88, 11, 22, 33, 44, 99, 22]

        list.remove(0);//删除指定下标元素
        list.removeFirst();//删除第一个元素
        list.removeLast();//删除最后一个元素
        System.out.println(list);//[22, 33, 44, 99]

        list.set(3,00);//将下标为3的元素设置为0
        System.out.println(list);//[22, 33, 44, 0]

        List<Integer> list1 = list.subList(0,4);//截取list 从[0,4)下标 并复制为新的链表
        System.out.println(list1);//[22, 33, 44, 0]

        list.clear();//清空链表
        System.out.println(list);//[]
    }

4.3 LinkedList 的遍历

注意 : 以下代码省略了 main 方法

        LinkedList<Integer> list = new LinkedList<>();
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(44);
        list.add(99);
        list.add(22);

① for each 遍历

        //for each 遍历
        for (int e:list) {
            System.out.print(e+" ");//11 22 33 44 99 22
        }
        System.out.println();

② for 循环遍历

        //for 循环遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");//11 22 33 44 99 22
        }
        System.out.println();

③ 迭代器遍历(正向遍历)

        //迭代器遍历(正向遍历)
        ListIterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");//11 22 33 44 99 22
        }
        System.out.println();

④ 迭代器遍历(方向遍历)

        ListIterator<Integer> it1 = list.listIterator(list.size());
        while (it1.hasPrevious()){
            System.out.print(it1.previous()+" ");//22 99 44 33 22 11
        }
        System.out.println();

5. LinkedList 与 ArrayList 的对比

5.1 场景选择

场景推荐使用原因
频繁随机访问ArrayList基于数组的索引访问效率更高（O (1)）
频繁插入删除LinkedList链表结构修改引用即可，无需移动元素
内存敏感场景ArrayList链表节点有额外内存开销
作为队列使用LinkedList实现了 Deque 接口，队列操作更便捷

5.2 区别

不同点ArrayListLinkedList
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持，时间复杂度 O (1)不支持，时间复杂度 O (N)
头插需要搬移元素，效率低，时间复杂度 O (N)只需修改引用的指向，时间复杂度 O (1)
插入空间不够时需要扩容没有容量的概念
应用场景元素高效存储 + 频繁访问任意位置插入和删除频繁

6. LinkedList 的模拟实现

①接口

public interface IList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void clear();
    public void display();
}

②具体方法的实现

public class MyLinkedList implements IList  {

    static class ListNode{//内部类
        public ListNode prev;//结点的前驱
        public ListNode next;//结点的后继
        public int val;

        public ListNode(int val){
            this.val = val;
        }
    }
    //类成员
        public ListNode head;//头结点
        public ListNode last;//尾结点

    //头插法
    @Override
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if(head == null){
            head = last = node;
        }else{
            node.next = head;
            head.prev = node;
            head = node;
        }
    }

    //尾插法
    @Override
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if(head == null){
            head = last = node;
        }else{
            last.next = node;
            node.prev = last;
            last = node;
        }
    }

    //寻找下标为 index 的结点
    private ListNode findIndex(int index){
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    //任意位置插入结点
    @Override
    public void addIndex(int index, int data) {
        int len = size();
        if(index<0||index>size()){
            return;
        }
        if(index == 0){
            addFirst(data);
            return;
        }
        if(index == len){
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index);
        cur.prev.next = node;
        node.next = cur;
        node.prev = cur.prev;
        cur.prev = node;
    }

    //查找是否包含 key 在链表中
    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur!=null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }


    @Override
    public void remove(int key) {
        ListNode 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) {
                        last = last.prev;
                    } else {
                        cur.next.prev = cur.prev;
                    }
                }
                return;
            }
                cur = cur.next;
        }
    }

    @Override
    public void removeAllKey(int key) {
        ListNode 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) {
                        last = last.prev;
                    } else {
                        cur.next.prev = cur.prev;
                    }
                }

            }
            cur = cur.next;
        }
    }

    //求链表的长度
    @Override
    public int size() {
        if(head == null){
            return 0;
        }
        ListNode cur = head;
        int count = 0;
        while (cur!=null){
            count++;
            cur = cur.next;
        }
        return count;
    }

    //清空链表
    @Override
    public void clear() {
        ListNode cur = head;
        while (cur!=null){
            ListNode curN = cur.next;
            cur.prev = null;
            cur.next = null;
            cur = curN;
        }
    }

    //打印链表
    @Override
    public void display() {
        ListNode cur = head;
        while (cur!=null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
}

③测试

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(12);//头插法
        myLinkedList.addLast(22);//尾插法
        myLinkedList.addFirst(45);
        myLinkedList.addFirst(22);
        myLinkedList.display();//22 45 12 22 
        
        myLinkedList.addIndex(2,44);//任意位置插入
        myLinkedList.display();//22 45 44 12 22
        
        myLinkedList.remove(45);//删除元素 45
        myLinkedList.display();//22 44 12 22 
        
        myLinkedList.removeAllKey(22);//删除所有元素 22
        myLinkedList.display();//44 12 
    }
}

完

LinkedList（链表）
m0_50744075的博客
09-14 580
链表
【数据结构】链表之LinkedList（无头双链表实现 + 详解 + 原码）
明志の博客
07-26 1987
LinkedList是无头双向非循环链表学习链表的知识一定要 结合图，多画图，才能深刻理解LinkedList官方文档LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。在集合框架中， LinkedList也实现了List接口。
集合框架源码学习之LinkedList
weixin_34138056的博客
03-19 255
0-1. 简介 0-2. 内部结构分析 0-3. LinkedList源码分析   0-3-1. 构造方法   0-3-2. 添加add方法   0-3-3. 根据位置取数据的方法   0-3-4. 根据对象得到索引的方法   0-3-5. 检查链表是否包含某对象的方法   0-3-6. 删除removepop方法 0-4. LinkedList类常用方法 简介 LinkedList是一个实现了...
ArrayList和LinkedList的区别
心若向阳 无谓悲伤
12-28 3311
ArrayList和LinkedList的异同点以及使用区别
LinkedList基本用法
热门推荐
i_lovefish的专栏
10-06 21万+
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用. LinkedList的构造函数如下 1. public LinkedList():  ——生成空的链表 2. public LinkedList(Collection col):  复制构造函数 1、获取链表的第一个和最后一个元素 [java] view plaincopy
什么是 LinkedList
weixin_34337381的博客
02-24 2028
一. 概述 LinkedList 是 Java 集合中比较常用的数据结构，与 ArrayList 一样，实现了 List 接口，只不过 ArrayList 是基于数组实现的，而 LinkedList 是基于链表实现的。所以 LinkedList 插入和删除方面要优于 ArrayList，而随机访问上则 ArrayList 性能更好。 除了 LIst 接口之外，LinkedList 还实现了 De...
LinkedList学习示例模拟堆栈与队列数据结构
09-04
本示例主要关注两种基本的数据结构：堆栈（Stack）和队列（Queue），并使用Java中的LinkedList类来模拟这两种数据结构。LinkedList是Java集合框架中的一种双向链表，它允许在列表的任何位置进行插入和删除操作，这...
C++数据结构实现之Linkedlist.zip
06-04
在这个"C++数据结构实现之Linkedlist.zip"压缩包中，我们可以预见到包含的是关于C++实现链表（Linked List）的详细教程或代码示例。 链表是一种线性数据结构，与数组不同，它不连续存储元素。链表由一系列节点组成...
数据结构-C++之06-linkedlist.zip
09-23
数据结构是计算机科学与工程领域的核心课程之一，它涉及到数据的组织、...本压缩包“数据结构-C++之06-linkedlist.zip”可能正是学习和实践C++链表操作的一个实用资源，对于广大编程学习者来说是一个值得探索的工具包。
数据结构-LinkedList
最新发布
决战软件之巅的博客
06-11 699
1）linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。2）能存储null值3）跟arrayList相比较，就真正的知道了，LinkedList在删除和增加等操作上性能好，而ArrayList在查询的性能上好4）从源码中看，它不存在容量不足的情况5）linkedList不光能够向前迭代，还能像后迭代，并且在迭代的过程中，可以修改值、添加值、还能移除值。6）linkedList不光能当链表，还能当队列使用，这个就是因为实现了Deque接口。
数据结构-C++之07-linkedlist.zip
09-23
在计算机科学领域，数据结构是一门研究组织数据以便于有效使用和处理的学科。C++是一种广泛使用的编程语言，它提供了丰富的数据结构类型和算法实现。在处理链表这样的非连续存储数据结构时，C++特别能够体现出它在...
LinkedList
一只菜鸟的练级路
03-15 219
LinkedList Doubly-linked list implementation of the List and Deque interfaces. Implements all optional list operations, and permits all elements (including null). 双链表实现了list和Deque接口。实现所有可选的列表操作，并允许所有元素(包括null)。 All of the operations perform as could be
手撕源码系列：深入理解LinkedList源码
NayelyA的博客
02-10 235
第一次读源码，可能有理解不对的地方，望包涵。 0.LinkedList简介 LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当做堆栈、队列或双端队列进行使用。 LinkedList实现List接口，能让它进行队列操作。 LinkedList实现Deque接口，即能将LinkedList当做双端队列使用。 LinkedList实现Clonea...
java提高篇（二二）-----LinkedList
chenssy 的技术博客
01-10 456
一、概述 LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。 LinkedList实现所有可选的列表操作，并允许所有的元素包括null。 除了实现 L...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值