LinkedList与链表

已于 2022-08-12 01:29:01 修改
阅读量244 收藏
点赞数
分类专栏： JAVA 笔记 数据结构 文章标签： 链表 数据结构 算法
于 2022-08-09 11:40:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54175406/article/details/126212350
版权
笔记 同时被 3 个专栏收录
64 篇文章 2 订阅
订阅专栏
JAVA
36 篇文章 0 订阅
订阅专栏
数据结构
12 篇文章 2 订阅
订阅专栏

文章目录

引入链表

顺序表的引入带给了我们许多便利，比如在随机访问元素时，可以做到简单快捷；可是我们也不难发现，对顺序表进行插入删除的操作时，就显得较为繁琐，因此我们引入了链表结构，帮助我们快速的进行插入删除等操作；

链表的结构

线性表的链式存储结构就是用一组任意的存储单元来存放线性表的数据元素，其中每个数据元素存储的信息包括2个部分：即存储数据本身信息的数值域和存储下一个数据元素地址的next域，这个数据元素就被称为结点；
这组存储单元可以是连续的，也可以是不连续的，由于使用链式结构时，因为我们可以得知后一个元素的地址，因此通过这个地址就可以找到下一个元素；

结点的结构单链表的结构我们就可以简单理解为这样：

在这里插入图片描述

单链表操作的模拟实现

为了更加深入了解单链表的结构，同时对后续代码进行检验，我们先手动创建一个单链表：

public class MyLinkedList {

    static class ListNode{
        public int val;     //数值域
        public ListNode next;       //下一个结点的地址

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

    public ListNode head;       //链表的头结点
    
    public void create(){
        ListNode listNode1=new ListNode(1);
        ListNode listNode2=new ListNode(2);
        ListNode listNode3=new ListNode(3);
        ListNode listNode4=new ListNode(4);
        ListNode listNode5=new ListNode(5);
        listNode1.next=listNode2;
        listNode2.next=listNode3;
        listNode3.next=listNode4;
        listNode4.next=listNode5;
        this.head=listNode1;
         }
    }

这样一个简单的单链表就创建完成了
在这里插入图片描述

  • 单链表的遍历；

大体思路：遍历就是要访问到链表的每一个结点，我们可以首先创建一个结点head,指向当前链表的第一个结点，如果结点head不为空，我们就可以打印该结点的值，然后结点head向后走，指向它的下一个结点，循环访问，循环打印；

//遍历单链表
    public void display(){
        ListNode head=this.head;
        while(head!=null){
            System.out.print(head.val+" ");
            head=head.next;
        }
        System.out.println();

    }
  • 打印链表的长度；

大体思路：打印链表的长度，其本质其实也是遍历链表，可以创建一个临时变量来记录，如果当前的结点不为空，临时变量+1，即可；

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

        }
        return count;
    }
  • 查找链表中是否包含了关键字key;

大体思路：代码的核心依然是进行遍历，如果在遍历的过程中找到了与关键字相同的结点，返回true即可；

  //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur=this.head;
        //这里的循环判断条件不能为cur.next!=null
        //否则如果是查找的值恰好为最后一个结点，不能进入循环，判断就会错误；
        while(cur!=null){
            if(cur.val!=key){
                cur=cur.next;
            }else{
                return true;
            }
        }
        return  false;
    }
  • 头插法

大体思路：头插法是在原链表的第一个结点前面插入新的结点，因此关键点就是让新结点的next指向原链表的第一个结点，然后更新插入之后的头结点；

  //头插法
    public void addFirst(int data) {
       ListNode node=new ListNode(data);

       //如果第一个结点为空，就是node的下一个结点为空，因此可以不用特殊考虑
      /* if(this.head==null){
           this.head=node;
       }*/
       node.next=this.head;
       this.head=node;
    }
  • 尾插法

大体思路：尾插法是在链表的最后一个结点后面插入新的结点，因此找到链表的最后一个结点就是关键；因为链表的最后一个结点的next域为null，因次利用这个特性就可以找到链表的最后一个结点；另外，尾插法我们需要考虑头结点为空的情况，因为当头结点为空时，我们访问一个空节点势必就会出现空指针异常；

  //尾插法
    public void addLast(int data) {
        ListNode cur=this.head;
        ListNode node=new ListNode(data);
        //头结点为空时
        if(this.head==null){
            head=node;
        }else{
            while (cur.next!=null){
                cur=cur.next;
            }
            cur.next=node;
        }
    }
  • 任意位置插入,第一个数据节点为0号下标；

大体思路：在任意位置插入，可以分为3种情况：插入到链表的最前面，可以直接使用头插法；插入到链表的最后，直接使用尾插法；在链表的任意中间位置插入，需要考虑插入位置的前一个元素和后一个元素，要去到后一个元素，就需要移动下标 -1次；

 //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data) {

        ListNode cur=this.head;
        ListNode pre=this.head;
        ListNode node=new ListNode(data);
        //如果需要插入到整个链表的最前面，直接使用头插法
        if (index==0){
            addFirst(data);
            return;
        }
        //插入到最后，直接使用尾插法
        if (index==size()){
            addLast(data);
            return;
        }

        while (index-1!=0){
            cur=cur.next;
            index--;
        }
        pre=cur;
        cur=cur.next;
        pre.next=node;
        node.next=cur;

    }
  • 清空链表

大体思路：很容易想到的清空方式就是直接将头结点置为空，由于链式结构的特点，后续的结点也会依次被清空，但这种做法显得粗暴；可以换一种方式一 一置空：

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

        this.head=null;


    }
  • 删除第一次出现关键字为key的节点；

大体思路：删除该结点，其实就是让该结点的上一个结点直接指向该结点的下一个结点，此时该结点不指向任何结点，也不被任何结点指向，相当于删除；

//删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur=this.head;
        ListNode pre=cur;

        if (this.head==null){
            System.out.println("链表为空，无法删除");
        }
        if (this.head.val==key){
            this.head=this.head.next;
        }
        while (cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
                return;
            }else{
                pre=cur;
                cur=cur.next;

            }
        }

    }
  • 删除所有值为key的节点；

大体思路：删除所有值为key的结点实际上是对删除第一次出现的关键字key的结点的一个拓展，与只删除一次大体类似，只需要在删完第一个以后继续向后遍历即可；

   //删除所有值为key的节点
    public void removeAllKey(int key){


        if (this.head==null){
            System.out.println("链表为空，无法删除");
        }


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

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

    }

LinkedList

Java中的链表LinkedList其底层就是一个双向链表，所谓双向链表，与单链表相比，其实就是一个结点增加个一个前驱，即一个双向链表的每个结点由3部分组成，即数值，前驱，后继；

LinkedList的模拟实现

双向链表的实现与单链表较为相似：

public class MyLinkedList {

    static class LinkNode {
        public int val;     //数值域

        public LinkNode prev;   //前驱

        public LinkNode next;   //后继

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

    }

    public LinkNode head;   //链表的头结点

    public LinkNode last;   //链表的尾巴结点


    //头插法
    public void addFirst(int data) {
        LinkNode node=new LinkNode(data);
        //如果当前链表为空，判断，防止出现空指针异常
        if(head==null){
            head=node;
            last=node;
        }else{
            node.next=head;
            head.prev=node;
            head=node;
        }


    }
    //尾插法
    public void addLast(int data){
        LinkNode node=new LinkNode(data);

        if (head==null){
            head=node;
            last=node;
        }
        last.next=node;
        node.prev=last;
        node.next=null;
        last=node;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){

        LinkNode node=new LinkNode(data);
        LinkNode cur=head;

        if(index<0||index>size()){
            System.out.println("插入位置不合法");
            return;
        }
        //插入位置为0，头插法
        if (index==0){
            addFirst(data);
            return;         //这里一定要注意返回
        }
        if (index==size()){
            addLast(data);
            return;
        }

        //在中间位置插入，首先让cur移动到要插入的位置
        while (index!=0){
            cur=cur.next;
            index--;
        }
        cur.prev.next=node;
        node.prev=cur.prev;
        node.next=cur;
        cur.prev=node;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        if(head==null){
            return false;
        }
        LinkNode cur=head;

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

    //删除第一次出现关键字为key的节点
    public void remove(int key){

        LinkNode cur=head;

        if(head==null){
            return;
        }

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

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

        while (cur!=null){

            if(cur.val==key){
                cur.prev.next=cur.next;
                cur.next.prev=cur.prev;
            }
            cur=cur.next;
        }

    }
    //删除所有值为key的节点
    public void removeAllKey(int key){

        LinkNode 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){
                        cur.next.prev=cur.prev;
                    }
                }
                cur=cur.next;
            }else{
                cur=cur.next;
            }

        }


    }
    //得到单链表的长度
    public int size(){
        int count=0;

        LinkNode cur=head;

        while (cur!=null){
            count++;
            cur=cur.next;
        }

        return count;
    }
    public void display(){
        LinkNode cur=head;

        while (cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
        System.out.println();

    }
    public void clear(){
        LinkNode cur = head;
        //遍历链表删除
        while (cur != null) {
            //需要记录下当前值为空的下一个结点
            LinkNode curNext = cur.next;
            ///cur.val = null;  //如果数组域是引用类型，需要手动置为null
            cur.prev = null;
            cur.next = null;
            cur = curNext;
        }
        head = null;
        last = null;
    }


}

LinkedList的具体使用

  • LinkedList的构造；
 public static void main(String[] args) {

        //没有参数的构造
        List<Integer> list1 = new LinkedList<>();

        list1.add(1);
        list1.add(2);
        list1.add(3);
        // 使用其他集合容器（list1）中的元素构造list3
        List<Integer> list3 = new LinkedList<>(list1);
    }
  • LinkedList的一些常用方法；
 public static void main(String[] args) {
        LinkedList<Integer> linkedList=new LinkedList<>();

        //插入，默认尾插
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        linkedList.add(4);
        linkedList.add(5);
        //System.out.println(linkedList);     // [1, 2, 3, 4, 5]

        //指定位置插入元素
        linkedList.add(2,9);   //将9插入到链表的2号位置
        //System.out.println(linkedList);     // [1, 2, 9, 3, 4, 5]

        //删除指定位置的元素
        linkedList.remove(1);       //默认第一个下标为0，删除下标为1位置的元素
        //System.out.println(linkedList);     // [1, 9, 3, 4, 5]

       //获取下标位置的元素
        int ret=linkedList.get(2);
        //System.out.println(ret);        // 3

        //根据下标设置元素值
        linkedList.set(3,8);
        //System.out.println(linkedList);     // [1, 9, 3, 8, 5]

        //判断链表中是否包含了某元素
        boolean b=linkedList.contains(9);
        //System.out.println(b);      //true

        //返回元素的下标，第一个
        int r=linkedList.indexOf(5);
        //System.out.println(r);      // 4

        //返回元素的下标，最后一个
        linkedList.add(3);
        int r1=linkedList.lastIndexOf(3);
        System.out.println(r1);     //5

        //截取链表的部分，以下标截取
        List list=linkedList.subList(2,5);
        System.out.println(list);       // [3, 8, 5]

        //清空链表
        linkedList.clear();
        //链表的长度
        int len=linkedList.size();
        System.out.println(len);         // 0



    }

  public static void main(String[] args) {

        //没有参数的构造
        List<Integer> list1 = new LinkedList<>();
        LinkedList<Integer> linkedList=new LinkedList<>();

        list1.add(1);
        list1.add(2);
        list1.add(3);
        // 使用其他集合容器（list1）中的元素构造list3
        List<Integer> list3 = new LinkedList<>(list1);

        //尾插入list1中的所有元素
        linkedList.addAll(list1);
        System.out.println(linkedList);     //[1, 2, 3]
    }

LinkedList的遍历

public static void main(String[] args) {
        LinkedList<Integer> linkedList1=new LinkedList<>();

        //插入，默认尾插
        linkedList1.add(1);
        linkedList1.add(2);
        linkedList1.add(3);
        linkedList1.add(4);
        linkedList1.add(5);

        //for-each循环

        for (int t:linkedList1) {
            System.out.print(t+" ");        // 1 2 3 4 5
        }

        System.out.println();
        //for循环
        for (int i = 0; i <linkedList1.size() ; i++) {
            System.out.print(linkedList1.get(i)+" ");       // 1 2 3 4 5
        }

        System.out.println();

        //使用迭代器遍历---正向遍历
        ListIterator<Integer> iterator=linkedList1.listIterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");      // 1 2 3 4 5 
        }

        System.out.println();

        //使用反向迭代器---反向遍历

        ListIterator<Integer> iterator1=linkedList1.listIterator(linkedList1.size());
        while (iterator1.hasPrevious()){
            System.out.print(iterator1.previous()+" ");     // 5 4 3 2 1 
        }

    }

ArraysList与LinkedList的区别（！）

  • ArraysList在物理和逻辑上都是连续的;LinkedList在物理上不连续，在逻辑上连续；
  • ArraysList基于数组实现；LinkedList基于双向链表实现；
  • ArraysList随机访问的时间复杂度O(1);LinkedList随机访问，时间复杂度为O(n)，因此随机访问时前者优于后者；
  • ArraysList对于随机访问更加高效；LinkedList对于插入和删除元素更加高效；
504 Gateway Time-out
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linkedlist_链表_
10-02
单双链表的创建，节点的添加与删除，链表逆序，链表遍历。
初学者关于集合框架
qq_50896786的博客
04-16 602
1、为什么使用集合 之前学习过的数组存在定容的缺陷，一旦数组定义好，数组长度就无法改变，如果需要改变数组长度，代码将会变得很复杂。但是使用集合就能提高数据的灵活性，同时java官网基于数组根据不同的数据结构，创建了多个类，而这些类统称为集合框架，还有就是java集合可以用来存储不同类型不同数量的对象，因此之后再说的集合框架时就表示多个类。 2.集合框架 ...
【集合】LinkedList底层原理
奋进的小白粥
02-18 480
1 前言 本人使用的是jdk1.8版本。 2 List集合继承结构 3 底层实现 LinkedList的底层是一个双端链表，每个节点有prev和next两个前、后指针。同时用first和last指针分别指向链表的头尾节点，方便对链表收尾进行插入删除等操作。因为是链表，所以LinkedList没有初始默认长度。 public class LinkedList<E> ...
java linkedlist 长度_Java集合之LinkedList
weixin_32017139的博客
02-13 2195
对于LinkedList来说，其基本特性如下：基本特性结论元素是否允许为null是元素是否允许重复是是否有序是是否线程安全否与ArrayList是一致的。源码分析本文使用的是JDK 1.8.0_201的源码。成员变量LinkedList是基于链表实现的，并且是双向链表结构。LinkedList类的主要成员变量：成员变量作用transient int size = 0;集合中元素的个数transie...
ArrayList和LinkedList简单分析
qq_29529381的博客
08-16 178
ArrayList和LinkedList 1.数据结构 ArrayList底层数据结构是Object[],初始长度为10 LinkedList在JDK1.7 时是循环链表，在JDK1.8时是双向链表，下图为JDK1.8时的LinkedList源码 2.插入和删除 2.1 ArrayList添加、删除、扩容 ArrayList在任意位置时的插入操作是要经过元素的拷贝的，此时的时间复杂度为O(n-i)。大量的数据移动会导致系统性能的下降，插入的位置越靠前系统的开销越大。 ArrayList在尾部添加数据
ArrayList和LinkedList实现原理
IT蜗牛的专栏
03-13 1200
一、ArrayList实现原理 ArrayList就是动态数组，ArrayList并不是线程安全的，允许 null 的存在，是有序的，初始容量大小为10，当超过容量后，会进行扩容，以原来容量的1.5倍来扩容，如之前的容量为10，下次扩容扩大到10 + 5，ArrayList的最大长度为 2^32 .当删除数组中间的元素，后面的元素都会向前移动。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，这种操作的代价是很高的，因此，如果可预知数据量的多少...
LinkedList:链表
07-03
链表Shashank Shekhar 的链接列表实现
LinkedList:链表算法
04-13
链表 链表算法 链表算法的实现，该算法从stdin读取用户命令并根据用户指令命令在链表上运行特定功能，例如：PUT n，GET n，LIST，FIRST，LAST，SORT，CLEAR，REMOVE n，EXIT，其中： PUT n-将一个整数n插入到链表中...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
集合List的理论最大长度（ArrayList\LinkedList）
雨易辰木的博客
06-10 9479
集合List的理论最大长度（ArrayList\LinkedList） 1.我们先来看ArrayList的长度（不考虑内存等，理论值） ArrayList我们都知道是数组实现的，那么数组的最大长度其实就是ArrayList的最大长度，说到这里，其实有人已经有答案了。其实我们看一下它的length属性就可以了。length属性是32位的有符号整数，它的最大值是2的31次幂，就是2G。为何有这个限制呢？为什么length的属性不是long型呢？我们假设一下，如果它是long型的，那么它的最大长度是2的63次幂。
LinkedList 学习
liulk20170518的博客
08-03 233
package cn.onloc.utils.conllection; import cn.onloc.utils.User; import java.util.*; public class LinkedList_1 { /** 链表集合 * 1、为什么在有了数组的情况下还需要链表？ * 数组是定长的，即使在初始化ArrayList()的时候我...
游戏开发 LinkedList
s178435865的专栏
12-20 550
linkedlist
LinkedList入门教程
最新发布
rqz__的博客
04-02 468
Java LinkedList是一种双向链表数据结构，可以用于存储和操作元素列表。它具有快速的插入和删除性能，但在访问特定元素时可能比数组慢。
Java代码优化细节
zj57356498318的博客
09-02 176
Java代码优化细节 前言 代码优化的目标： 减少代码的体积 提高代码运行的效率 代码优化细节 1、尽量指定类、方法的final修饰符带有final修饰符的类是不可派生的。 在Java核心API中，有许多应用final的例子，例如java.lang.String，整个类都是final的。为类指定final修饰符可以让类不可以被继承，为方法指定final修饰符可以让方法不可以被重写。如...
LinkedList
学习小窝
04-01 186
继承关系 Arraylist是以数组实现集合，而LinkedList是以双向链表实现的集合，LinkedList的继承关系如下: Linkedlist与Arraylist的区别有: 1.Arraylist直接继承AbstractList，而Linkedlist是继承的AbstractSequentialList 2.Arraylist实现了RandomAccess接口可以直接用foreach遍历...
【数据结构与算法】LinkedList的模拟实现
冲击大厂之路!!!
09-22 769
LinkedList的模拟实现！
获取链表长度
an13654067079的博客
08-10 1763
获取链表长度
线性表——链表(初始化，查找，求表长)
weixin_47924016的博客
10-18 975
链表的初始化，查找
Linked List-查找链表的长度（迭代和递归）Find Length of a Linked List (Iterative and Recursive) （6）
weixin_45428910的博客
02-22 220
Linked List-查找链表的长度（迭代和递归）Find Length of a Linked List (Iterative and Recursive) （6）
Linkedlist双向链表
03-29
与单向链表不同，双向链表可以在任何一个节点中进行插入和删除操作，因为每个节点都包含指向前一个节点和后一个节点的指针。 双向链表的优点是可以很方便地在任何位置进行插入和删除操作，但它的缺点是需要更多的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值