6. LinkedList与链表

已于 2024-09-06 10:16:13 修改
阅读量779 收藏 10
点赞数 5
分类专栏： Java数据结构 文章标签： 链表 数据结构 java
于 2024-09-06 09:46:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45674716/article/details/141950601
版权

一、ArrayList的缺陷

通过源码知道，ArrayList底层使用数组来存储元素，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。所以，java集合中又引入了LinkedList，即链表结构。

二、链表

1. 链表的概念及结构

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

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

1.1 单向或者双向 

1.2 带头或者不带头

1.3 循环或者非循环

重点掌握两种:  

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

2. 链表的实现

import java.util.List;

public class MySingleLinkedList {

    static class ListNode {
        public int val;
        public ListNode next;

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

    public ListNode head;//代表链表的头节点

    public void createList() {
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);
        ListNode node5 = new ListNode(56);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        this.head = node1;
    }

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

    /**
     * 从指定位置 newHead 开始打印链表
     * @param newHead
     */
    public void display(ListNode newHead) {
        ListNode cur = newHead;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

    public int size(){
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    public void addFirst(int val) {
        ListNode node = new ListNode(val);
        node.next = head;
        head = node;
    }

    public void addLast(int val) {
        ListNode node = new ListNode(val);
        if(head == null) {
            head = node;
            return;
        }
        ListNode cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

    public void addIndex(int index,int val) {
        //1.判断index的合法性
        try {
            checkIndex(index);
        }catch (IndexNotLegalException e) {
            e.printStackTrace();
        }
        //2.index == 0  || index == size()
        if(index == 0) {
            addFirst(val);
            return;
        }
        if(index == size()) {
            addLast(val);
            return;
        }
        //3. 找到index的前一个位置
        ListNode cur = findIndexSubOne(index);
        //4. 进行连接
        ListNode node = new ListNode(val);
        node.next = cur.next;
        cur.next = node;
    }
    private ListNode findIndexSubOne(int index) {
        int count = 0;
        ListNode cur = head;
        while (count != index-1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

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

    public boolean contains(int val) {
        ListNode cur = head;
        while (cur != null) {
            if(cur.val == val) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    public void remove(int val) {
        if(head == null) {
            return;
        }
        if(head.val == val) {
            head = head.next;
            return;
        }
        ListNode cur = head;
        while (cur.next != null) {
            if(cur.next.val == val) {
                ListNode del = cur.next;
                cur.next = del.next;
                return;
            }
            cur = cur.next;
        }
    }

    public void removeAllKey(int val) {
        //1. 判空
        if(this.head == null) {
            return;
        }
        //2. 定义prev 和 cur
        ListNode prev = head;
        ListNode cur = head.next;
        //3.开始判断并且删除
        while(cur != null) {
            if(cur.val == val) {
                prev.next = cur.next;
                //cur = cur.next;
            }else {
                prev = cur;//prev = prev.next;
                //cur = cur.next;
            }
            cur = cur.next;
        }
        //4.处理头节点
        if(head.val == val) {
            head = head.next;
        }
    }

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

三、链表面试题

1. 删除链表中等于给定值 val 的所有节点。

2. 反转一个单链表。

3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

4. 输入一个链表，返回该链表中倒数第k个结点。

5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。

7. 链表的回文结构。

8. 输入两个链表，找出它们的第一个公共结点。

9. 给定一个链表，判断链表中是否有环。

10. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL。

四、LinkedList的模拟实现

public class MyLinkedList {

    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

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

    public ListNode head;
    public ListNode last;

    //头插法
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = node;
            last = node;
            //return;
        }else {
            node.next = head;
            head.prev = node;
            head = node;
        }
    }
    //尾插法
    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;
        }
    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        if(index < 0 || index > size()) {
            return;
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = searchIndex(index);
        ListNode node = new ListNode(data);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

    private ListNode searchIndex(int index) {
        ListNode cur = head;
        int count = 0;
        while (count != index) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

    //查找是否包含关键字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(){
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur =cur.next;
        }
        return count;
    }
    public void display(){
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur =cur.next;
        }
        System.out.println();
    }


    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur = head;
        while (cur != null) {
            if(cur.val == key) {
                if(cur == head) {
                    head = head.next;
                    //判断 头节点是不是1个
                    if(head != null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if(cur.next == null) {
                       //cur.prev.next = cur.next;
                        last = cur.prev;
                    }else {
                        //cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                    }
                }
                return;
            }else {
                cur = cur.next;
            }
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur = head;
        while (cur != null) {
            if(cur.val == key) {
                if(cur == head) {
                    head = head.next;
                    //判断 头节点是不是1个
                    if(head != null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if(cur.next == null) {
                        //cur.prev.next = cur.next;
                        last = cur.prev;
                    }else {
                        //cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                    }
                }

            }
            cur = cur.next;
        }
    }

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

}

五、LinkedList的使用

1. 什么是LinkedList

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

在集合框架中，LinkedList也实现了List接口，具体如下：

【说明】

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

2. LinkedList的使用

2.1 LinkedList的构造

public static void main(String[] args) {
    // 构造一个空的LinkedList

    List<Integer> list1 = new LinkedList<>();
    
    List<String> list2 = new java.util.ArrayList<>();
    list2.add("JavaSE");
    list2.add("JavaWeb");
    list2.add("JavaEE");
    // 使用ArrayList构造LinkedList

    List<String> list3 = new LinkedList<>(list2);
}
2.2 LinkedList的其他常用方法介绍

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

六、ArrayList和LinkedList的区别

The丶Closer
关注
专栏目录
阅读java.util.LinkedList笔记
weixin_42785633的博客
05-16 201
1,LinkedList类定义实现和继承关系： public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, java.io.Serializable{…} 2，LinkedList中定义的成员变量： transient int size = 0; transient Node ...
LinkedList与链表
如风暖阳的博客
07-05 489
LinkedList与链表
【详解LinkedList与链表】
TheMyth142857的博客
05-18 1730
本章主要介绍了LinkedList的概念，以及它底层的数据结构，然后通过模拟实现更加了解LinkeList与链表的关系。文章有错误的地方，还请广大读者提出宝贵意见！！！
java中LinkedList与链表
m0_62055442的博客
10-01 539
java中LinkedList与链表
java.util.linkedList
Recently祝祝的博客
09-11 301
链表是一个很好从存储器，在数据的删除和添加中有着高效的效率。 使用情况： 1：需要频繁的对列表进行删除修改 2：需要频繁的访问列表里的数据 构造方法： 链表的实现与继承关系： 链表的常用方法： 经常用到的就这几个方式： addFirst：加入元素到开头 addLast：从末尾加入元素 add（int index，element e） :在指定索引下加入元素 removeFirst:移除第一个元素 remove: toArray(): 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素
LinkedList和链表
2301_78804510的博客
04-21 1214
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
LinkedList双向链表的详细介绍
qq_68754937的博客
07-11 1350
在Java源代码中，可以看出其常用的父接口有List接口，而List接口又继承于Collection接口，由此可以推断出：LinkedList类父接口为List，祖宗接口为Collection。5.根据指定索引删除元素public E remove(int index)，首先对index索引进行校验，校验通过后调用unlink(Node x)方法，判断要删除的元素所处的位置，进行不同的操作，最后把要删除的元素清空，减小集合大小，增加修改计数器。
数据结构之LinkedList与链表
sniper_fandc的博客
03-22 2837
目录 1.LinkedList的特点和存在意义 2.LinkedList的简单使用 2.1.LinkedList的构造 2.2.常见方法 2.3.遍历 3.链表结构 4.简单实现 4.1单向无头不循环链表 4.2.双向无头不循环链表 5.ArrayList与LinkedList的不同 1.LinkedList的特点和存在意义 LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了...
【数据结构】LinkedList与链表
m0_74336101的博客
07-21 1029
LinkedList与链表主要内容
zuiduanlujing.rar_链表类
09-21
一个好的链表类应该包含节点（Node）类和链表（LinkedList）类。节点类通常包含数据和指向下一个节点的指针，而链表类应包含插入、删除、查找和排序等方法。在实现归并排序时，链表类需要提供必要的接口，如获取链表...
java.util.LinkedList 类
fujiedada的专栏
12-25 1022
1 引言 ​ 前面我们介绍了List集合的一种典型实现 ArrayList，我们知道 ArrayList 是由数组构成的，这次我们介绍 List 集合的另一种典型实现 LinkedList，这是一个由链表构成的数组。 ​ 大家都知道数组作为数据存储结构有一定的缺陷。在无序数组中，搜索性能差，在有序数组中，插入效率又很低，而且这两种数组的删除效率都很低，并且数组在创建后，其大...
Java双链表V3.0加入迭代器，浅析与Java.util.LinkedList的区别
通过`Iterable`接口，`MyLinkedList`可以与Java的增强for循环无缝配合，这在处理大量数据时提供了便利。然而，尽管V3.0在某些方面可能不如Java内置的`LinkedList`（如`java.util.LinkedList`）强大，但它作为教学或...
java.util.LinkedList学习笔记
leipeng的专栏
11-09 2280
LinkedList是两个接口(List和Deque)的混合实现。其实现了List接口中所有的可选操作，并且LinkedList允许所有元素（包括null）的插入和访问操作。LinkedList的所有操作均基于双向链表实现，当根据下标对链表中的元素进行访问，将通过从头至尾或者从尾至头遍历链表中的所有元素，来到达指定位置。LinkedList和ArrayList都不是
数据结构之——树形结构
m0_71974552的博客
10-07 1508
数据结构之树形结构：强大而灵活的数据组织方式
知识改变命运 数据结构【优先级队列(堆)】
2402_84062064的博客
10-08 1684
堆的使用
java-02 数据结构-队列
wyh106115的博客
10-09 921
在Java中，队列是一种常见的数据结构，用于在保持顺序的同时存储和检索数据。Java提供了java.util.Queue接口，它的常见实现包括ArrayDeque、LinkedList和PriorityQueue等。
Redis Bitmap 数据结构在权限管理、数据分析以及广告投放中的应用
最新发布
欢迎来到【技术拾光者】，在这里，我们专注分享编程教程、技术趋势、实战案例和优质资源。不定期举办技术问答、专家访谈和职业指导。加入我们，共同探索技术世界，提升技能，拓展职业道路！
10-11 364
Redis 的 Bitmap 是一种高效的位操作数据结构，适用于存储和处理大量布尔值（0 或 1）。本文探讨了 Redis Bitmap 在多个实际应用场景中的使用方法，包括权限管理以及数据分析和广告投放。通过具体的 Java 示例代码，展示了如何利用 Bitmap 提高数据存储和处理的效率。这些示例不仅帮助理解 Bitmap 的基本操作，还展示了其在实际业务中的广泛应用，提供了实用的解决方案。
数据结构--堆的深度解析
2302_81410974的博客
10-08 2173
堆（Heap）是一种非常重要的非线性数据结构，广泛应用于各种算法和问题解决中，如优先队列、堆排序、Top-k 问题等。本文将深入解析堆的定义、类型、操作、应用及其优缺点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值