LinkedList与链表

已于 2022-12-02 10:27:10 修改
阅读量595 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 java
于 2022-11-26 20:33:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_63918780/article/details/127548914
版权
本文介绍了链表的基本概念，包括单向和双向链表，并提供了链表的模拟实现，包括插入、删除、查找等操作。接着讲解了Java中的LinkedList，强调其作为双向链表的特性，适合频繁的插入和删除操作，而不适合随机访问。最后对比了ArrayList和LinkedList在存储空间、随机访问和插入删除效率上的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1.链表

2.链表的模拟实现

3.LinkedList的模拟实现

4.LinkedList的使用

4.1 什么是LinkedList

4.2 LinkedList的使用

5.ArrayList和LinkedList的区别

我的GitHub：Powerveil · GitHub

我的Gitee：Powercs12 (powercs12) - Gitee.com

皮卡丘每天学Java

1.链表

链表也是线性表的一种。

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

注意：

  1. 从上图可以看出，链式结构在逻辑上是连续的，但是在物理上不一定连续

  2. 现实中的结点一般都是从堆上申请出来

  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环 

虽然有这么多的链表的结构，但是我们重点掌握两种:

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  • 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

2.链表的模拟实现

public class TestSingleList {

    public ListNode head;

    static class ListNode {
        public int val;
        public ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }

    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.printf(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    public void display(ListNode node) {
        ListNode cur = node;
        while (cur != null) {
            System.out.printf(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

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


    //得到单链表的长度
    public int size() {
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }



    //头插法:O(1)
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

    //尾插法:O(n)
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
        } else {
            ListNode cur = head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }


    private void checkIndex(int index) {
        if (index < 0 || index > size()) {
            throw new IndexNotLegalException("index的值不合法");
        }
    }


    //任意位置插入，第一个数据节点0号下标
    public void addIndex(int index, int data) {
        checkIndex(index);
        //下标为0是头插
        if (index == 0) {
            addFirst(data);
        }
        //下标为size是尾插
        if (index == size()) {
            addLast(data);
        }
        //中间插
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index - 1);
        node.next = cur.next;
        cur.next = node;
    }

    //找到指定下标节点
    public ListNode findIndex(int index) {
        ListNode cur = head;
        while (index > 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
//        if (head == null) {
//            throw new RuntimeException("链表没有元素不可以删除");
//        }
        if (head.val == key) {
            head = head.next;
            return;
        }

        ListNode cur = searchPrevOfKey(key);
        if (cur == null) return;
        ListNode del = cur.next;
        cur.next = del.next;
    }


    //根据值找到前一个节点
    private ListNode searchPrevOfKey(int key) {
        if (head == null) return null;

        ListNode cur = head;
        while (cur.next != null) {
            if (cur.next.val == key) return cur;
            cur = cur.next;
        }
        return null;
    }


    //删除所有值为key的节点
    public void removeAllKey(int key) {
        if (head == null) return;
        ListNode cur = head;
        while (cur.next != null) {
            ListNode curNext = cur.next;
            if (curNext.val == key) {
                cur.next = curNext.next;
            } else {
                cur = curNext;
            }
        }
        if (head.val == key) {
            head = head.next;
        }
    }



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

}

3.LinkedList的模拟实现

public class MyLinkedList {
    // 头节点
    public ListNode head;
    // 节点
    static class ListNode {
        public int val;
        public ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }

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

    // 从某个节点开始打印
    public void display(ListNode node) {
        ListNode cur = node;
        while (cur != null) {
            System.out.printf(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

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


    // 得到单链表的长度
    public int size() {
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }



    // 头插法:O(1)
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

    // 尾插法:O(n)
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
        } else {
            ListNode cur = head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    // 检查下标是否合法
    private void checkIndex(int index) {
        if (index < 0 || index > size()) {
            throw new IndexNotLegalException("index的值不合法");
        }
    }


    // 任意位置插入，第一个数据节点0号下标
    public void addIndex(int index, int data) {
        checkIndex(index);
        // 下标为0是头插
        if (index == 0) {
            addFirst(data);
        }
        // 标为size是尾插
        if (index == size()) {
            addLast(data);
        }
        // 中间插
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index - 1);
        node.next = cur.next;
        cur.next = node;
    }

    // 找到指定下标节点
    public ListNode findIndex(int index) {
        ListNode cur = head;
        while (index > 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    // 删除第一次出现关键字为key的节点
    public void remove(int key) {
//        if (head == null) {
//            throw new RuntimeException("链表没有元素不可以删除");
//        }
        if (head.val == key) {
            head = head.next;
            return;
        }

        ListNode cur = searchPrevOfKey(key);
        if (cur == null) return;
        ListNode del = cur.next;
        cur.next = del.next;
//        cur.next = cur.next.next;
    }


    // 根据值找到前一个节点
    private ListNode searchPrevOfKey(int key) {
        if (head == null) return null;

        ListNode cur = head;
        while (cur.next != null) {
            if (cur.next.val == key) return cur;
            cur = cur.next;
        }
        return null;
    }


    // 删除所有值为key的节点
    public void removeAllKey(int key) {
        if (head == null) return;
        ListNode cur = head;
        while (cur.next != null) {
            ListNode curNext = cur.next;
            if (curNext.val == key) {
                cur.next = curNext.next;
            } else {
                cur = curNext;
            }
        }
        if (head.val == key) {
            head = head.next;
        }
    }


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

4.LinkedList的使用

4.1 什么是LinkedList

官方文档

LinkedList (Java Platform SE 8 )

LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

 下面是类图

1. LinkedList实现了List接口
2. LinkedList的底层使用了双向链表
3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问

注意：插入和删除的时间复杂度都为O(n)，因为找到节点需要遍历。

4.2 LinkedList的使用

LinkedList的构造

方法解释
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List
@SuppressWarnings({"all"})
public class Test {
    public static void main(String[] args) {
        // 构造一个空的LinkedList
        LinkedList<String> linkedList1 = new LinkedList<>();
        List<String> list = new ArrayList<>();

        list.add("Hello world!");
        list.add("每天学Java");
        list.add("逐渐提升");
        list.add("...");
        // 使用ArrayList构造LinkedList
        LinkedList<String> linkedList2 = new LinkedList<>(list);

    }
}

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 位置元素
boolean 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(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        System.out.println(list);
        // 在起始位置插入0
        list.add(0, 0); // add(index, elem): 在index位置插入元素elem
        System.out.println(list);
        list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
        list.removeFirst(); // removeFirst(): 删除第一个元素
        list.removeLast(); // removeLast(): 删除最后元素
        list.remove(1); // remove(index): 删除index位置的元素
        System.out.println(list);
        // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
        if (!list.contains(1)) {
            list.add(0, 1);
        }
        list.add(1);
        System.out.println(list);
        System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
        System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
        int elem = list.get(0); // get(index): 获取指定位置元素
        list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
        System.out.println(list);
        // subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
        List<Integer> copy = list.subList(0, 3);
        System.out.println(list);
        System.out.println(copy);
        list.clear(); // 将list中元素清空
        System.out.println(list.size());
    }

LinkedList的遍历

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        // foreach遍历
        for (int e:list) {
            System.out.print(e + " ");
        }
        System.out.println();
        // 使用迭代器遍历---正向遍历
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();
        // 使用反向迭代器---反向遍历
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
            System.out.print(rit.previous() +" ");
        }
        System.out.println();
    }

5.ArrayList和LinkedList的区别

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

复杂链表的复制
Web_boom的博客
02-03 526
我们常见的链表中一般有3种类型的指针：指向下一个节点、指向上一个节点、尾节点指向头节点。在复杂链表中，每个节点除了拥有指向下一个节点的指针外，还会有一个指针用于指向链表中的任意节点或者null。本文就跟大家分享下如何复制一个复杂链表，欢迎各位感兴趣的开发者阅读本文。最近还整理一份JavaScript与ES的笔记，一共25个重要的知识点，对每个知识点都进行了讲解和分析。能帮你快速掌握JavaScript与ES的相关知识，提升工作效率。
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2686
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
数据结构--LinkedList与链表
weixin_53860901的博客
10-25 313
LinkedList与链表一丶关于ArrayList和LinkedList的区别二丶关于LinkedList的使用 我们上篇博客讲了什么是ArrayList，这一篇博客说的是LinkedList。 一丶关于ArrayList和LinkedList的区别 这两种结构的底层数据结构不同，因为数据结构不同所以导致了很多方面的不同。 这里大致说一下。 1.ArrayList底层是数组，而LinkedList底层是链表 2.对于按照index下标随机查找，因为ArrayList底层是数组，所以其查找效率更好。 3.
数组和链表的区别、ArrayList和LinkedList的区别、使用LinkedList模拟栈和队列
终生学习践行者
07-24 4196
介绍了数组和链表的区别，ArrayList和LinkedList的区别以及使用LinkedList模拟栈和队列。
05 ArrayList LinkedList CopyOnWriteArrayList
weixin_43338519的博客
08-07 178
1. ArrayList 基于数组实现，实现了 List 接口。（允许传入空值和重复元素） 当添加元素数量大于数组容量时，通过1.5倍的扩容机制进行扩容。 实现了 RandomAccess 接口，表明它具有随机访问的能力，RandomAccess 接口里其实什么内容都没有，它只是一个标识，ArrayList 能实现随机访问真正依靠的是基于数组实现的底层结构。 新增和删除操作会造成数组元素的移动，时间复杂度为 O(n)。由于支持随机访问，所以get和set操作的效率很高，时间复杂度为 O(1)。所以 Arr
how to copy a linkedlist
tianqio的专栏
03-12 577
Copy link-list, If You Can Make a seprate copy of a linked list that has an extra pointer than theregular ones. This pointer points to any randam  node in thelist.i.e.::node structure
linkedList-clone制造deep copy
sinat_21555157的博客
05-26 379
有两个clone图和链表的题。基本的思路是，用一个hashmap来维护新旧对应的节点的映射关系。138那个题除了这种基本方法，还可以不用hashmap直接修改指针。 133. Clone Graph 给一个联通无向图的reference。node的定义： class Node { public int val; public List neighbors; } 求一个这个图的deep copy。 思路是：由旧图的reference point开始遍历旧图（数据结构给的是neighbor list，就用
java 实现克隆_java – 在LinkedList上实现克隆
weixin_32482133的博客
03-07 220
我试图在DoubleLinkedList上实现clone()方法.现在,问题是通过“约定”实现它比创建一个新的DoubleLinkedList并用我当前的DoubleLinkedList的所有元素填充它要麻烦得多.这样做有什么不方便吗？这是我目前的做法：@Overridepublic DoubleLinkedList clone() {DoubleLinkedList dll = new Doub...
LinkedList基本用法
热门推荐
i_lovefish的专栏
10-06 21万+
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用. LinkedList的构造函数如下 1. public LinkedList():  ——生成空的链表 2. public LinkedList(Collection col):  复制构造函数 1、获取链表的第一个和最后一个元素 [java] view plaincopy
java集合框架05——ArrayList和LinkedList的区别
武哥聊编程
04-13 11万+
前面已经学习完了List部分的源码，主要是ArrayList和LinkedList两部分内容，这一节主要总结下List部分的内容。 List概括 先来回顾一下List在Collection中的的框架图： 从图中我们可以看出： 1. List是一个接口，它继承与Collection接口，代表有序的队列。 2. AbstractList是一个抽象类，它继承与AbstractColle
Linkedlist-025-复杂链表的复制
bakaka9527的博客
03-24 377
题目 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空） 思路 代码 public class Solution { public RandomListNode Clone(RandomListNode pHead) ...
数据库blog2_数据结构与效率
🙂‍↕️
05-18 887
无
Redis——底层数据结构
2401_83176717的博客
05-16 1623
Redis采用了链式哈希（拉链法）来解决哈希冲突，这与Java中的hashMap是相似的。哈希表的底层其实是数组，通过计算对象的哈希值对数组长度取余来确定索引位置，可以在O1的时间获取数据。
【数据结构】二叉搜索树
2301_80541270的博客
05-18 1241
左子树所有节点的键值小于当前节点的键值。右子树所有节点的键值大于当前节点的键值。左右子树也必须是二叉搜索树。二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，系列容器底层就是二叉搜索树，其中map/set不支持插入相等值，支持插入相等值。
Android 性能优化入门（一）—— 数据结构优化
最新发布
tmacfrank
05-18 1211
一款 app 除了要有令人惊叹的功能和令人发指交互之外，在性能上也应该追求丝滑的要求，这样才能更好地提高用户体验，响应速度一项就主要取决于数据结构和算法。
Java SE编程：LinkedList与链表数据结构解析
与ArrayList相比，LinkedList在进行添加和删除操作时效率更高，因为这些操作在链表中只需要改变相邻元素之间的链接，而不需要像ArrayList那样进行大量的数组移动。LinkedList类继承了AbstractSequentialList类，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值