LinkedList与链表

最新推荐文章于 2025-12-19 16:22:21 发布
原创 最新推荐文章于 2025-12-19 16:22:21 发布 · 1.9k 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构 #java

前情回顾：

上一篇文章讲了ArrayList与顺序表，那么ArrayList有缺陷吗？当然有，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后 搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。

因此，Java集合中又引入了LinkedList，即链表结构。

一、链表

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

例如：火车可以看成一个链表。

如图所示：

  1. 链表结构在逻辑上是连续的，但是在物理上不一定连续。
  2. 现实中的节点一般都是从堆（内容后边都会补上的）上申请出来的。
  3. 从堆上申请的空间，是按照一定策略分配的，多次申请的空间可能连续也可能不连续。

实际中链表的结构非常多样，例如其中几种：

虽然有许多链表结构，但是我们重点掌握两种：

无头单向肺循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如 哈希桶、图的邻接表等等。

无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

在说LinkList之前，先说如何实现链表。

二、链表的实现

emm……咋一看图感觉是挺多的，实际写下来确实很多，让咱来逐个解决。

三、基本操作

必要内容写好

public class SingleLinkedList implements IList{
    static class ListNode{
        public int val;
        public ListNode next;
        ListNode(int val){
            this.val=val;
        }
    }
    public ListNode head;
}
1.头插

写链表不要需要考虑空间是否足够，所以会省略一些处理方式。

头插不需要考虑链表为 null 情况，没有往哪放。

所以直接 new 一个节点 data，让 data 指向头结点，将头结点改为 data 。

代码如下：

public void addFirst(int data){
        //new一个节点
        ListNode node =new ListNode(data);
        node.next=head;
        head=node;
    }
2.尾插

定义一个变量遍历链表，当变量的 next 为空时，插入 new 的节点。

代码如下：

public void addLast(int data){
        ListNode node =new ListNode(data);
        //判断链表是否为空
        if(head==null){
            head=node;
            return;
        }
        ListNode cur=head;
        while (cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }
3.任意位置插入

要判断位置是否合法，但不用考虑空间大小问题。

那中间插入怎么操作？

可以这么想，如果 index 为零，就是对应位置，看图：

完整代码如下：

public void addIndex(int index,int data){
        int pos=size();
        if(index < 0 || index > pos){
            System.out.println("index位置不合法");
            return;
        }
        ListNode node=new ListNode(data);
        if(index==0){
            addFirst(data);
        }
        if (index==pos){
            addLast(data);
        }
        ListNode cur=head;
        while (index-1!=0){
            cur=cur.next;
            index--;
        }
        node.next=cur.next;
        cur.next=node;
    }

4.查找链表关键字

很简单，先判断为空，再遍历链表，查找 key 如果有返回TRUE,否则，返回FALSE。

代码如下：

public boolean contains(int key){
        if(head==null){
            return false;
        }
        ListNode cur=head;
        while (cur!=null){
            if(cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }
5.删除第一个关键节点

判断 head 为空，再判断 head 是否等于 key ，若等于则让 head=head.next。

        if(head==null){
            return;
        }
        if (head.val==key){
            head=head.next;
            return;
        }

接下来是数值在长度范围内情况，怎么找呢？如果 cur != null 遍历，走到 key 值就无法执行操作。

其实答案已经在图上了，既然 cur != null 遍历不行，那就用 cur.next != null 遍历，当 next.val 等于key时，返回 cur。

代码如下：

    public void remove(int key){
        ListNode cur= findKey(key);
        if(cur==null) {
            return;
        }
        ListNode del=cur.next;
        cur.next=del.next;
    }
    public ListNode findKey(int key){
        ListNode cur=head;
        while (cur.next!=null){
            if(cur.next.val==key){
                return cur;
            }
            cur=cur.next;
        }
        return null;
    }
6.删除所有关键节点

移除一个都很麻烦了，这个还要全部移除…咱也不是怕事的人，上去解决它。

照例判断 head为空，再用 cur.next != null 遍历即可，那如果是其他情况呢？

所以不能 cur.next != null 遍历。难道用 cur !=null 遍历？

哎！别说，好像还真行，看图：

代码如下：

public void removeAllKey(int key){
        if(head==null){
            return;
        }
        ListNode pre =head;
        ListNode cur= head.next;
        while (cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
                cur=cur.next;
            }else {
                pre=cur;
                cur=cur.next;
            }
        }
        if (head.val==key){
            head=head.next;
        }
    }
7.链表长度

剩下几个都比较简单了。

遍历链表，全部加上，返回值。

代码：

public int size(){
        int len=0;
        ListNode cur=head;
        while (cur!=null){
            len++;
            cur=cur.next;
        }
        return len;
    }
8.遍历链表

遍历然后打印。

代码：

public void display() {
        ListNode cur =head;
        while (cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
        System.out.println();
    }
9.清空链表

遍历，全部置空。

代码：

public void clear(){
        ListNode cur=head;
        while (cur!=null){
            ListNode curN=cur.next;
            cur.next=null;
            cur=curN;
        }
    }

无头非循环链表说完了，现在我们对单链表有一些了解，接下来继续说双向链表。

四、LinkedList

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

在集合框架中，LinkedList也实现了List接口，底层使用了双向链表，任意位置增删效率较高，时间复杂度为O(1)，比较适合任意位置插入的场景，但是不支持随即访问。

1.LinkedList的常用操作

其实和单链表基本是一样的，只是更方便一些，话不多说，上图：

接口 IList 不用管，暂时用不到。

必要内容：

public class MyLinkedList implements IList{
    static class ListNode{
        public int val;
        public ListNode next;
        //这个用来记录前一个节点的地址
        public ListNode pre;  
        ListNode(int val){
            this.val=val;
        }
    }
    public ListNode head;
    public ListNode last;
}
1.头插

和单链表不一样的地方估计各位已经看出来了，没错，多了 prev 这个位置，用来记录前一个节点的地址，需要注意的是双向链表要判断为空情况，原因很简单，看图：

其他和单链表一样，代码如下：

public void addFirst(int data){
        public void addFirst(int data){
        ListNode node =new ListNode(data);
        if(head==null){
            head=last=node;
        }
        node.next=head;
        head.pre=node;
        head=node;
    }
    }
2.尾插

有了 last 节点会方便很多，不需要遍历链表找为空元素，所以思路非常简单，判断为空情况，然后直接用 last 尾插。图示（为空和头插一样）：

代码如下：

public void addLast(int data){
        ListNode node =new ListNode(data);
        if (head==null){
            head=last=node;
        }else {
            last.next=node;
            node.pre=last;
            last=last.next;
        }
    }
3.任意位置插入

这和单链表完全一样，虽说多了一个记录节点，但还是要遍历一次。

图示：

代码如下：

public void addIndex(int index,int data){
        int len=size();
        if (index<0 || index>len){
            System.out.println("index位置不合法");
        }
        if(index==0){
            addFirst(data);
        }
        if (index==len){
            addLast(data);
        }
        ListNode node =new ListNode(data);
        ListNode cur=head;
        //查找可以写成一个方法
        while (index-1!=0){
            cur= cur.next;
            index--;
        }
        node.next=cur;
        cur.pre.next=node;
        node.pre=cur.pre;
        cur.pre=node;
    }
4.查找关键字

和单链表一样。代码：

public boolean contains(int key){
        if(head==null){
            return false;
        }
        ListNode cur=head;
        while (cur!=null){
            if(cur.val==key){
                return true;
            }
        }
        return false;
    }
5.删除第一个key节点

直接上图示说明：

代码如下：

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.pre=null;
                    }
                    else {
                        cur.pre.next=cur.next;
                        if(cur.next==null){
                            last=last.pre;
                        }else {
                            cur.next.pre=cur.pre;
                        }
                    }
                    return;
                }
                cur=cur.next;
            }
        }
    }
6.移除所有key节点

和上边的代码完全一样，思路也完全一样，跟着图走一遍就理解了。

7.链表长度和有效元素

和单链表完全一样。

代码：

    public int size(){
        int len=0;
        ListNode cur=head;
        while (cur!=null){
            len++;
            cur=cur.next;
        }
        return len;
    }
    public void display(){
        ListNode cur=head;
        while (cur!=null){
            System.out.println(cur.val+" ");
            cur=cur.next;
        }
    }
8.清除链表元素

遍历链表全部置空，记录节点也得置空。代码：

public void clear(){
        ListNode cur =head;
        while (cur!=null){
            ListNode curN=cur.next;
            cur.pre=null;
            cur.next=null;
            cur=curN;
        }
        head=last=null;
    }

到这就全部完成了，是不是感觉双向链表更好用，需要考虑的限制没有单链表那么多，不过实际用起来各有利弊，后续有内容再补充。

---------------------------------------------------------------完---------------------------------------------------------------

LinkedList双向链表的详细介绍
qq_68754937的博客
07-11 1687
在Java源代码中，可以看出其常用的父接口有List接口，而List接口又继承于Collection接口，由此可以推断出：LinkedList类父接口为List，祖宗接口为Collection。5.根据指定索引删除元素public E remove(int index)，首先对index索引进行校验，校验通过后调用unlink(Node x)方法，判断要删除的元素所处的位置，进行不同的操作，最后把要删除的元素清空，减小集合大小，增加修改计数器。
java中LinkedList与链表
m0_62055442的博客
10-01 644
java中LinkedList与链表
【详解LinkedList与链表】
TheMyth142857的博客
05-18 2156
本章主要介绍了LinkedList的概念，以及它底层的数据结构，然后通过模拟实现更加了解LinkeList与链表的关系。文章有错误的地方，还请广大读者提出宝贵意见！！！
【数据结构】LinkedList与链表
m0_73107796的博客
08-05 2541
熟悉链表、掌握使用并模拟实现
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2761
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
LinkedList和链表
2301_78804510的博客
04-21 1437
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
Java SE编程：LinkedList与链表数据结构解析
与ArrayList相比，LinkedList在进行添加和删除操作时效率更高，因为这些操作在链表中只需要改变相邻元素之间的链接，而不需要像ArrayList那样进行大量的数组移动。LinkedList类继承了AbstractSequentialList类，并...
【数据结构】LinkedList与双向链表
qq_61903414的博客
12-20 2119
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
数据结构04——二叉树搜索树BST
moranxiao199的博客
12-16 502
Find查找的效率取决于树的高度，所以我们希望这个树尽量的平衡，不要出现一边倒。支持：查找（Search）、插入（Insert）、删除（Delete）第三种，删除的结点有左、右两颗子树：用另一个结点代替被删除的结点，同一组元素，如果插入顺序不同，二叉搜索树的形态可以完全不同。② 如果 X 大于根结点的关键值，在右子树中进行继续搜索；③ 若两者比较结果相等，搜索完成，返回指向此结点的指针。查找从根结点开始，如果树为空，返回 NULL。：将其父结点的指针指向被删除结点的孩子结点。
数据结构：矩阵
闲余知道
12-16 875
数据结构：矩阵
八大排序之：冒泡排序、快速排序和堆排序
t2786024916的博客
12-16 868
冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。这个算法的名称由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端（升序排列）。
Python基础知识-数据结构篇
最新发布
weixin_50659451的博客
12-19 659
数据结构可变？有序？允许重复？典型用途list✅✅✅通用序列，动态数组tuple❌✅✅固定结构，函数返回值dict✅✅（3.7+）键❌ / 值✅键值映射，快速查找set✅❌❌去重，成员检测，集合运算str❌✅✅文本处理frozenset❌❌❌不可变集合，可用作键。
数据结构（四）图结构
I_love_Kaopanfan的博客
12-18 609
本文系统介绍了图论的基础知识和算法实现。主要内容包括：图的定义与基本概念（顶点、边、度、连通性等）；图的存储结构（邻接矩阵、邻接表、十字链表等）；图的遍历算法（DFS和BFS）；最小生成树算法（Prim和Kruskal）；最短路径算法（Dijkstra和Floyd）；以及拓扑排序的原理与实现。文章详细阐述了各种算法的核心思想、时间复杂度分析，并提供了完整的C语言实现代码示例。通过本文可以全面了解图论的基本概念和经典算法，掌握图的存储与遍历方法，以及解决实际问题的算法应用。
数据结构（树）
m0_64823929的博客
12-15 263
3，完全二叉树，对于一颗有n个结点的二叉树按层序编号，如果编号i（1<=i<=n）的结点于同样深度的。n个结点的有限集合，集合要么为空树，要么由一个根结点和两棵互不相交，分别称谓根结点的左子树和。中序，左根右，先从根开始（不是先访问根），从左开始访问，在访问根，在访问右结点。后序，左右根，先从根开始（不是先访问根），先访问左，在访问右。1，斜树，所有的结点都只有左子树，左斜树，所有结点都只有右子树，右树。树的度数是指，这棵树中，最大的结点的度数，称谓树的度数。前序，根左右，先访问根，然访问左，访问右。
C++ 数据结构关于二叉搜索树
m0_72697497的博客
12-17 966
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树的平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。2.左右两个孩子都在的情况，可以使用结点替换法，先找cur的左子树中的最右结点（左子树中最大的那个结点值），然后交换cur和leftMax的结点值，再对leftMax的左边是否为空进行判断就可以。情况d：在它的右子树中寻找中序下的第一个结点（关键值最小），用它的值填补到被删除结点中，再来处理该结点的删除问题---替换法删除。
【数据结构】考研408 | 冲突解决精讲: 拉链法——链式存储的艺术与优化
蒙奇D索大的博客
12-17 985
【数据结构】考研408 | 冲突解决精讲: 拉链法——链式存储的艺术与优化 详细介绍哈希冲突的第一种解决方法——拉链法……
【数据结构：从0到1】-15-高级哈希函数
技术探索者之路 - 一个专注于软件开发技术的实践型博客，涵盖移动应用开发、后端架构、Python编程和算法数据结构等核心技术领域。欢迎各位道友光临，喜欢本博主的别忘了一键三连哦。
12-15 1056
本文带你掌握四种哈希技术背后原理及其应用场景：1）普通哈希通过分桶提升查找效率，但存在哈希碰撞问题；2）全域哈希采用随机函数家族防御恶意攻击，确保冲突概率可控；3）完美哈希为静态数据集提供零冲突的O(1)查找，通过两级哈希实现；4）可扩展哈希通过目录结构和局部扩容实现动态调整，避免全表重建。这些技术体现了哈希表在效率、安全性和扩展性方面的不同权衡方案。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值