LinkedList与链表

最新推荐文章于 2023-07-18 22:51:16 发布
最新推荐文章于 2023-07-18 22:51:16 发布
阅读量369 收藏 13
点赞数 25
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61688804/article/details/125653403
版权

在这里插入图片描述

🎉🎉🎉写在前面：
博主主页：🌹🌹🌹戳一戳，欢迎大佬指点！
博主秋秋：QQ：1477649017 欢迎志同道合的朋友一起加油喔💪
目标梦想：进大厂，立志成为一个牛掰的Java程序猿，虽然现在还是一个小菜鸟嘿嘿
-----------------------------谢谢你这么帅气美丽还给我点赞！比个心-----------------------------
在这里插入图片描述

LinkedList与链表

LinkedList与链表

集合类的背后是数据结构，ArrayList的背后是数组，最基本的数据结构。LinkedList的背后是链表，也是数组结构。

一，链表

1.1，链表的概念和结构

链表是一种物理存储上的非连续的存储结构，数据元素的逻辑顺序是依靠引用连接次序来实现的。,链表形象的比喻类似于一个小火车，一节节的串起来。
在这里插入图片描述

在这里插入图片描述

head就是一个引用类型的变量，用来存储第一个节点的地址。这种存储形式叫做链式存储。

我们的实际中，链表形式有带头的，不带头的，单向的，双向的，循环的，非循环的，所以排列组合后，我们可以得到8种结构。

在这里插入图片描述

认识一下什么叫做带头和不带头：

在这里插入图片描述

由图可知，带头其实就是有一个专门节点作为头节点，这个头节点不用来存储值，只是用来永远的标识这是这个链表的头位置，不管后面的节点做任何的操作，头节点的位置永远是它不变（也就是head的值不变）。那么不带头其实就是没有一个专门的头节点，它只是默认第一个为头节点，那么在进行操作之后，例如删除节点，那么头节点的位置就会变化，没有一个固定的值（head没有固定值）。

1.2，模拟实现一个单链表集合类

public class SingleList {
    static class Node{//内部类，节点类
        public int val;
        public Node next;//next指向下一个节点

        public Node(int val) {
            this.val = val;
        }
    }
    public Node head;//存储头结点的引用

    public void createList(){
        //创建四个节点，只赋值
        Node node1 = new Node(10);
        Node node2 = new Node(20);
        Node node3 = new Node(30);
        Node node4 = new Node(40);
        //下面把各个节点串起来
        node1.next = node2;//node2就是第二个节点的地址
        node2.next = node3;
        node3.next = node4;
        head = node1;
    }

}

问题：我们如何去遍历一个链表？

在这里插入图片描述

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

程序运行结果：

在这里插入图片描述

上面虽然确实是已经把链表遍历并且输出了，但是存在一个问题，因为我们是直接动的head指针，所以最终遍历完之后head = null，但是链表中的元素是全都存在的，那你下次再要访问这个链表，但是head等于null，那是不是就有问题了，所以我们不能直接动head,要用一个中间变量去遍历。

【代码改进：】

public void displayList(){
    Node cur = this.head;
    while(cur != null){
        System.out.print(cur.val + " ");
        cur = cur.next;
    }
}

上面是一个链表的基本属性，那么下面我们就加上对其的操作方法，形成一个完整的集合类。

public class SingleList {
    static class Node{//内部类，节点类
        public int val;
        public Node next;//next指向下一个节点

        public Node(int val) {
            this.val = val;
        }
    }
    public Node head;//存储头结点的引用

    public void createList(){
        //创建四个节点，只赋值
        Node node1 = new Node(10);
        Node node2 = new Node(10);
        Node node3 = new Node(10);
        Node node4 = new Node(40);
        //下面把各个节点串起来
        node1.next = node2;//node2就是第二个节点的地址
        node2.next = node3;
        node3.next = node4;
        head = node1;
    }

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

    //头插法  时间复杂度O(1)
    public void addFirst(int data){
        Node node = new Node(data);
        node.next = this.head;
        this.head = node;
//        当你的链表里面没有元素时，头插其实也满足，因为空的时候head = null
    };
    //尾插法    时间复杂度O(n) 最坏情况下需要找到尾巴
    public void addLast(int data){
        Node node = new Node(data);
        if(this.head == null){
            head = node;
        }else{
            Node cur = this.head;
            //        先将cur移动到尾部
            while(cur.next != null){
                cur = cur.next;
            }
            cur.next = node;
        }

    };
    //任意位置插入,第一个数据节点为0号下标
    private boolean checkIndex(int index){
        if(index < 0 || index > size()){
            throw new IndexLegalException("插入下标不合法！");
        }
        return true;
    }

    private Node findIndexSubOne(int index){
//        找到index-1的节点
        Node cur = this.head;
        while(index - 1 != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }
    public void addIndex(int index,int data){
//        其他位置，先检验下标合法性
        try{
            checkIndex(index);
            if(index == 0){
//        那就是头插
                addFirst(data);
                return;
            }
            if(index == size()){
//            那就是尾插
                addLast(data);
                return;
            }
//            中间插入
            Node cur = findIndexSubOne(index);//找到index - 1位置的节点
            Node node = new Node(data);
            node.next = cur.next;
            cur.next = node;

        }catch (IndexLegalException e){
            e.printStackTrace();
        }

    };
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        Node cur = this.head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    };
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        if(this.head == null){
            return;
        }
        if(this.head.val == key){
            head = head.next;
            return;//必须要return
        }
        Node cur = searchPrevOfKey(key);
        if(cur == null){
            return;//cur == null 就说明没有找到这么一个key值节点
        }
        cur.next = cur.next.next;
    };

    private Node searchPrevOfKey(int key) {
//        找到key值这个节点的前一个节点
        Node cur = this.head;
        while(cur.next != null){//遍历链表
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        if(this.head == null){
            return;//链表为空
        }
        Node node = new Node(-1);//虚拟节点
        node.next = this.head;
        Node prev = node;
        Node cur = this.head;
//        Node prev = this.head;
//        Node cur = this.head.next;
        while(cur != null){
            if(cur.val == key){
                cur = cur.next;
                prev.next = cur;
            }else{
                prev = cur;
                cur = cur.next;
            }
        }
        this.head = node.next;
        //特殊情况，头节点也为key
//        if(this.head.val == key){
//            head = head.next;
//        }
    };
    //得到单链表的长度
    public int size(){
        int count = 0;
        Node cur = this.head;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    };
    public void clear(){
        this.head = null;//直接把头干掉，那么后续节点就没人引用，就连锁反应，一个个被回收
        //也可以遍历，一个个的置为null，但是相对比较麻烦，不是很有必要
    };
}

【头插图示解析：】

在这里插入图片描述

【尾插图示解析：】

在这里插入图片描述

【index位置插入图示解析：】

在这里插入图片描述

【删除第一次出现的key：】

在这里插入图片描述

【删除所有出现的key：】

在这里插入图片描述

三，LinkedList模拟实现

LinkedList背后的数据结构就是一个双向的链表。结构如下：

在这里插入图片描述

不得不说，双向链表可真是比单向链表舒服多了，既可以记录尾部的位置，还能记录前驱的地址，不要很强大了！

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;//原链表为空的情况下，头节点，尾节点都是node
            last = node;
        }else{
//            链表不为空的情况下，头插，node的prev为null，不需要考虑
            node.next = head;
            head.prev = node;
            head = node;//把head更新一下,尾节点是不需要更新的
        }


    };
    //尾插法
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(head == null){//如果刚开始链表就为null
            head = node;
            last = node;
        }else{
            last.next = node;
            node.prev = last;
            last = node;
        }
    }
    private boolean checkAddIndex(int index){
        if(index < 0 || index > size()){
            throw new IndexException("index不合法！");
        }
        return true;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
//        先检查index的合法性
        try{
            checkAddIndex(index);
            ListNode node = new ListNode(data);
//        先找到index的元素
            if(index == 0){
                addFirst(data);
                return;//如果index == 0就是头插
            }
            if(index == size()){
                addLast(data);
                return;//就是尾插
            }
//        中间插入
            ListNode cur = head;
            while(index != 0){//cur往后走index步，找到index位置的元素
                cur = cur.next;
                index--;
            }
            node.next = cur;
            node.prev = cur.prev;
            cur.prev.next = node;
            cur.prev = node;
        }catch (IndexException e){
            e.printStackTrace();
        }
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur = this.head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                if(cur == head){//如果是删除第一个节点
                    if(head.next == null){//并且链表就只存在第一个节点
                        head = null;
                    }else{
                        head = head.next;
                        head.prev = null;
                    }
                }else{//删除的不是第一个节点
                    if(cur == last) {//是最后一个节点
                        cur.prev.next = null;
                        last = cur.prev;
                    }else{
                        cur.next.prev = cur.prev;
                        cur.prev.next = cur.next;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
//        逻辑就是上面的删除首次出现，只不过就是每次删除了没有直接return掉
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                if(cur == head){//如果是删除第一个节点
                    if(head.next == null){//并且链表就只存在第一个节点
                        head = null;
                    }else{
                        head = head.next;
                        head.prev = null;
                    }
                }else{//删除的不是第一个节点
                    if(cur == last) {//是最后一个节点
                        cur.prev.next = null;
                        last = cur.prev;
                    }else{
                        cur.next.prev = cur.prev;
                        cur.prev.next = cur.next;
                    }
                }
            }
            cur = cur.next;
        }
    }
    //得到单链表的长度
    public int size(){
        ListNode cur = this.head;
        int count = 0;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }
    public void display(){
        ListNode cur = this.head;
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    public void clear(){
        ListNode cur = head;
        while(cur != null){
            ListNode curNext = cur.next;
            cur.next = null;
            cur.pre = nnull;
            cur = curNext;
        }
        head = null;
        last = null;
    }

}

【头插图示：】

在这里插入图片描述

【尾插图示：】

在这里插入图片描述

【index位置插入：】

在这里插入图片描述

最后注意一下双向链表的clear()函数不能只单单把head,last置为null就可以了，因为每个节点的pre也算是引用着上一个节点，所以是需要我们遍历然后一个个置为空的，最后再把head与last置为空就完成了整个链表的清空。

四，LinkedList的使用

LinkedList实现了List接口，方法众多。

4.1，LinkedList的多元化使用

我们知道，双向链表的使用是十分普遍的，也正因为它的功能的强大，所以对于LinkedList而言，它不仅仅可以作为双向链表使用，还可以作为栈，队列来使用，具体使用场景后面会介绍。

如此，我们可以发现，在LinkedList的源码中，有很多相似的方法。

在这里插入图片描述

由图，我们可以看到，光是插入的方式就多种多样，因为LinkedList作为不同的对象进行使用的时候，方法需要进行区分，尽管都只是对于链表进行操作。

4.2，LinkedList的使用示例

【构造方法】

ArrayList<Integer> arrayList = new ArrayList<>();
LinkedList<Integer> linkedList = new LinkedList<>();//无参构造
LinkedList<Integer> linkedList2 = new LinkedList<>(arrayList);//有参构造
//public LinkedList(Collection<? extends E> c)

有参构造的这种模式在之前的ArrayList里面就介绍过，只要是实现了Collection接口的类，并且类中参数类型只有E和E的子类的类，都可以直接作为构造参数传入LinkedList里面，进行辅助构造。

【其他方法】

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        Person tmp = (Person) o;
        if(this.name.equals(((Person) o).name) && this.age == ((Person) o).age){
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "name:" + this.name + " ; " + "age:"+ this.age;
    }
}
public class TestDemo220707 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(9);
        arrayList.add(10);
        arrayList.add(20);


        LinkedList<Integer> linkedList = new LinkedList<>();//无参构造
        linkedList.addAll(arrayList);//尾插arraylist中的所有元素
        System.out.println(linkedList);
        List ret = linkedList.subList(0,2);
        System.out.println(ret);//注意你通过ret是可以修改到linkedlist中的内容的

        LinkedList<Person> linkedList1 = new LinkedList<>();
        linkedList1.add(new Person("xiaowang",18));
        linkedList1.add(new Person("xiaoli",19));
        System.out.println(linkedList1);
        linkedList1.remove(new Person("xiaoli",19));//Person类需要重写equals方法
        System.out.println(linkedList1);


    }
}

在这里插入图片描述

上面把几个相对于比较难一点的方法进行了示例，至于还有一些比较常规的操作方法，大家可以自行去查看帮助文档，然后进行实操。

【LinkedList的遍历】

public class TestDemo220707 {
    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();//无参构造
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);

        //1,直接输出
        System.out.println(linkedList);

        //2,foreach循环
        for (Integer x:linkedList) {
            System.out.print(x + " ");
        }
        System.out.println();

        //3,for循环
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.print(linkedList.get(i) + " ");
        }
        System.out.println();

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

        ListIterator<Integer> it2 = linkedList.listIterator(linkedList.size());//从后往前
        while(it2.hasPrevious()){
            System.out.print(it2.previous() + " ");
        }
        System.out.println();
    }
}

在这里插入图片描述

遍历的方法比较多，这里注重关注一个迭代器的方法， ListIterator it2 = linkedList.listIterator(linkedList.size());当我们传入链表的长度后，我们的迭代器对象会直接来到链表的尾部，开始从后面往前面打印，因为是双向链表，有前驱信息。

五，ArrayList与LinkedList对比

在这里插入图片描述

最后，今天的文章分享比较简单，就到这了，如果大家觉得还不错的话，还请帮忙点点赞咯，十分感谢！🥰🥰🥰
在这里插入图片描述

努力学习.java
关注
专栏目录
LinkedList（链表）
m0_50744075的博客
09-14 520
链表
【数据结构】链表LinkedList
qq_61862008的博客
11-18 1153
链表以及LinkedList介绍
集合框架（2）——LinkedList（链表）
aigo_2021的博客
02-05 1011
一、 LinkedList（链表） 每个元素有几个属性，存储值、存储上一个元素的引用(地址)、存储下一个元素的引用(地址) LinkedList是双向链表的数据结构 LinkedList源码实现 1.定义Node内部类 //定义一个节点类 （内部类） class Node{ private Node prev;//左节点，存储上一个元素的地址 private Node next;//右节点，存储下一个元素的地址 private Object data;//数据域，存储
学习LinkedList看这篇就够了（源码分析）
∑
10-02 620
链表 LinkedList是基于链表结构的一种List，在分析LinkedList源码前有必要对链表结构进行说明。 链表的概念 链表是由一系列非连续的节点组成的存储结构，简单分下类的话，链表又分为单向链表和双向链表，而单向/双向链表又可以分为循环链表和非循环链表，下面简单就这四种链表进行图解说明。 单向链表 单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指...
Java SE编程：LinkedList与链表数据结构解析
与ArrayList相比，LinkedList在进行添加和删除操作时效率更高，因为这些操作在链表中只需要改变相邻元素之间的链接，而不需要像ArrayList那样进行大量的数组移动。LinkedList类继承了AbstractSequentialList类，并...
LinkedList双向链表源码分析（附详细图解！！）
最新发布
A_diligent_man的博客
07-18 1238
本文章分析LinkedList源码。
使用java模拟实现LinkedList单向链表
weixin_42022728的博客
03-13 453
1. 基础知识 线性表常见的分为顺序表(vector和ArrayList)和链表(LinkedList) 单向链表只能由前驱找到后继,每个节点有数据和指向下一个节点的指针 优缺点:增删快,查找满 增加节点:新节点指针指向后一个节点,新节点的前一个节点指针指向新节点. 删除节点:被删除的节点的前一个节点指向被删除节点指向的后一个节点. 为了使操作一致,使用增加使用头结点(哑元节点)的方法. 2....
LinkedList:链表
03-13
链表与数组不同，它不依赖于物理存储位置的连续性，而是通过节点之间的引用（或称为指针）来组织数据。在Python中，我们可以使用内置的`collections.deque`或者自定义类来实现链表。 标题提到的"LinkedList"包含了...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
Linked_List实现 链表
12-25
这个链表是我在数据结构大作业中写的，可直接运行。分享在这里供初学数据结构的同学参考
Linked List 链表详解
爱.NET
02-26 235
本文是stanford cs library中两篇关于linked list的文章合体版 linked list basics linked list problems 我觉得这两篇讲linked list的文章写的非常非常好，所以在博客里自己写一下，也算是温习巩固数据结构的知识了 本文代码下载：http://download.csdn.net/detail/stevemarbo/40...
python 双向链表_面试官：LinkedList是单向链表还是双向链表？
weixin_39947908的博客
11-26 440
面试官：你能说说 LinedList 吗？Python 小星：LinedList 数据结构是链表，查询慢，增删快。面试官：那 LinkedList 是单向链表还是双向链表？Python 小星：双向链表面试官：那 LinkedList 是双向循环链表吗？Python 小星：......面试官：没事，那我问你 LinkedList 为什么不用单链表，而是用双链表？Python 小星：......面试官...
LinkedList（链表列表）
qq_39396275的博客
07-20 992
LinkedList主要有两种形式：单向链表和双向链表（一般会用 双向链表） 根据ＡＰＩ１.６中可以知道： １.和ＡｒｒａｙＬｉｓｔ一样，ＬｉｎｋｅｄＬｉｓｔ是线程不同步的，同步可用方法： List list = Collections.synchronizedList(new LinkedList(…));２.此类实现List 接口。LinkedList 类还为在列表的开头及结尾 get、rem
LinkedList链表（单向链表）
Avices
08-02 417
LinkedList链表（单向链表） 链表的优点： 由于链表上的元素在空间存储上内存地址不连续。所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议使用LinkedList。 链表的缺点： 不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率较低。 单链表中的节点。节点是单向链表中基本的单元。 每一个节点Node都有两个属性： 一个属性
链表LinkedList
小猪快跑
01-14 544
链表介绍链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是
链表(LinkedList)
weixin_51971817的博客
01-21 2314
链表是有序的列表，但是其在内存的存储不一定连续。
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5365
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力学习.java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值