• LinkedList与链表

    目录

    一、链表的概念和结构

    概念

    结构

    1、单向或双向

    2、带头或不带头

     3、循环或非循环

    二、链表的实现

    1、无头单向非循环链表

    1.1头插法

    1.2尾插法

    1.3任意位置插入数据

    1.4查找是否存在某个值

    1.5删除第一次出现的key节点

    1.6删除所有值为key的节点

    1.7得到单链表的长度

    1.8打印单链表的值

    1.9清空链表

    三、LinkedList的模拟实现

    无头双向链表

    3.1头插法

    3.2尾插法

    3.3求链表长度

    3.4任意位置插入

    3.5检查链表是否包含某个值

    3.6删除第一次出现关键字的节点

    3.7删除所有出现关键字的节点

    3.8打印链表

    3.9清空链表

    四、LinkedList的使用

    简单介绍

    说明：

     LinkedList的构造

    LinkedList的一些常用方法

    注意事项

    五、ArrayList和LinkedList的区别

    一、链表的概念和结构

    概念

    链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

    在我看来，链表和火车车厢的结构比较类似，是由一节一节的车厢连接起来的。

     注意：

    1. 这个时候就能看出，链式结构在逻辑上是连续的，但是在物理上不一定是连续的。
    2. 现实中的节点都是从堆上申请的空间开辟的。

    结构

    实际中链表的结构主要分以下几个方面：

    1、单向或双向

    2、带头或不带头

     3、循环或非循环

     注意：Java集合中LinkedList底层是无头双向循环链表

     

    二、链表的实现

    1、无头单向非循环链表

    1.1头插法

    注意：

    单链表中头节点很烦人，不论是插入还是删除均需考虑头节点，因为其没有前驱。

    所有的点操作（"."）均需注意空指针情况

    1. //头插法
    2.     public void addFirst(int data) {
    3.         //1.拿到一个实体
    4.         ListNode node = new ListNode(data);
    5.  
    6.         //2.插入
    7.         //如果是第一次插入，直接找到头节点
    8.         if (this.head == null) {
    9.             this.head = node;
    10.             last = node;
    11.         }else {
    12.             //不是第一次插入
    13.             node.next = head;
    14.             head.prev = node;
    15.             head = node;
    16.         }
    17.     }

    1.2尾插法

    1. //尾插法
    2.     public void addLast(int data) {
    3.         ListNode node = new ListNode(data);
    4.         if (head == null) {
    5.             head = node;
    6.             last = node;
    7.         }else {
    8.             ListNode cur = head;
    9.             while (cur.next != null) {
    10.                 cur = cur.next;
    11.             }
    12.             cur.next = node;
    13.         }
    14.     }

    有了头插法和尾插法我们就能调用这两个方法来创建链表，这里我就没吧代码拿出来了。

    1.3任意位置插入数据

    1. //检查index下标是否合法
    2.     private void checkIndex(int index) {
    3.         if(index < 0 || index > size()) {
    4.             //throw new IndexOutOfBoundsException("index位置不合法！");
    5.  
    6.             throw new IndexNotLegalException("index位置不合法！");
    7.         }
    8.     }
    9.  
    10.     //任意位置插入,第一个数据节点为0号下标
    11.     public void addIndex(int index,int data) {
    12.         checkIndex(index);
    13.         if (index == 0) {
    14.             addFirst(data);
    15.             return;
    16.         }
    17.         if (index == size()) {
    18.             addLast(data);
    19.             return;
    20.         }
    21.  
    22.         //不是头插尾插，且index合法
    23.         ListNode node = new ListNode(data);
    24.         ListNode cur = findIndexSubOfOne(index);
    25.         node.next = cur.next;
    26.         cur.next = node;
    27.     }
    28.  
    29.     private ListNode findIndexSubOfOne(int index) {
    30.         ListNode cur = head;
    31.         while (index - 1 != 0) {
    32.             cur = cur.next;
    33.             index--;
    34.         }
    35.         return cur;
    36.     }

    1.4查找是否存在某个值

    就是简单的遍历链表

    1. //查找是否包含关键字key是否在单链表当中
    2.     public boolean contains(int key) {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             if(cur.val == key) {
    6.                 return true;
    7.             }
    8.             cur = cur.next;
    9.         }
    10.         return false;
    11.     }

    1.5删除第一次出现的key节点

    在删除某个节点的时候，我们以防在删除之后，这个节点后面的节点丢失，我们在删除这个节点的时候要先把这个节点后面的节点记录并链接起来

    1. //删除第一次出现关键字为key的节点
    2.     public void remove(int key) {
    3.         //情况没处理
    4.         if(head.val == key) {
    5.             head = head.next;
    6.             return;
    7.         }
    8.         ListNode cur = searchPrevOfKey(key);
    9.         if(cur == null)
    10.             return;
    11.         ListNode del = cur.next;
    12.         cur.next = del.next;
    13.     }
    14.  
    15.     /**
    16.      * 找到关键字key的前驱
    17.      * @param key
    18.      * @return
    19.      */
    20.     private ListNode searchPrevOfKey(int key) {
    21.         ListNode cur = this.head;
    22.         while (cur.next != null) {
    23.             if(cur.next.val == key) {
    24.                 return cur;
    25.             }
    26.             cur = cur.next;
    27.         }
    28.         return null;
    29.     }

    1.6删除所有值为key的节点

    1. //删除所有值为key的节点
    2.     public void removeAllKey(int key) {
    3.         if(head == null) return;
    4.         ListNode prev = head;
    5.         ListNode cur = head.next;
    6.         while (cur != null) {
    7.             if(cur.val == key) {
    8.                 prev.next = cur.next;
    9.                 cur = cur.next;
    10.             }else {
    11.                 prev = cur;
    12.                 cur = cur.next;
    13.             }
    14.         }
    15.         if(head.val == key) {
    16.             head = head.next;
    17.         }
    18.     }

    1.7得到单链表的长度

    1. //得到单链表的长度
    2.     public int size() {
    3.         ListNode cur = head;
    4.         int count = 0;
    5.         while (cur != null) {
    6.             count++;
    7.             cur = cur.next;
    8.         }
    9.         return count;
    10.     }

    1.8打印单链表的值

    1. //打印
    2.     public void display() {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             System.out.print(cur.val+" ");
    6.             cur = cur.next;
    7.         }
    8.         System.out.println();
    9.     }

    1.9清空链表

    1. //清空
    2.     public void clear() {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             ListNode curNext = cur.next;
    6.             cur.next = null;
    7.             cur = curNext;
    8.         }
    9.         head = null;
    10.     }

    三、LinkedList的模拟实现

    无头双向链表

    首先定义这个类哦

    3.1头插法

    1. //头插法
    2.     public void addFirst(int data){
    3.         ListNode node = new ListNode(data);
    4.  
    5.         if (head == null) {
    6.              head = node;
    7.              last = node;
    8.         }else {
    9.             node.next = head;
    10.             head.pre = node;
    11.             head = node;
    12.         }
    13.     }

    3.2尾插法

    1. //尾插法
    2.     public void addLast(int data) {
    3.         ListNode node = new ListNode(data);
    4.  
    5.         if (head == null) {
    6.             head = node;
    7.             last = node;
    8.         }else {
    9.             last.next = node;
    10.             node.pre = last;
    11.             last = last.next;
    12.         }
    13.     }

    3.3求链表长度

    1.  //计算链表长度
    2.     public int size() {
    3.         int count = 0;
    4.         ListNode cur = head;
    5.         while (cur != null) {
    6.             count++;
    7.             cur = cur.next;
    8.         }
    9.  
    10.         return count;
    11.     }

    3.4任意位置插入

    1. //检查index是否合法
    2.     private boolean checkIndex(int index) {
    3.         if (index < 0 || index > size()) {
    4.             throw new IndexOutOfBoundsException("插入位置不合法！");
    5.         }else {
    6.             return true;
    7.         }
    8.     }
    9.  
    10.     //任意位置插入,第一个数据节点为0号下标
    11.     public void addIndex(int index,int data) {
    12.         if(checkIndex(index) == true) {
    13.             if (index == 0) {
    14.                 addFirst(index);
    15.             }
    16.             if (index == size()) {
    17.                 addLast(index);
    18.             }
    19.  
    20.             ListNode node = new ListNode(data);
    21.             //找到当前index节点的地址
    22.             ListNode cur = findIndex(index);
    23.  
    24.             node.next = cur;
    25.             cur.pre.next = node;
    26.             node.pre = cur.pre;
    27.             cur.pre = node;
    28.  
    29.         }
    30.  
    31.     }
    32.  
    33.     //找到当前index节点的地址
    34.     private ListNode findIndex(int index) {
    35.         ListNode cur = head;
    36.         while (index != 0) {
    37.             cur = cur.next;
    38.             index--;
    39.         }
    40.         return cur;
    41.     }

    3.5检查链表是否包含某个值

    1. //查找是否包含关键字key是否在单链表当中
    2.     public boolean contains(int key) {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             if(cur.val == key) {
    6.                 return true;
    7.             }
    8.             cur = cur.next;
    9.         }
    10.         return true;
    11.     }

    3.6删除第一次出现关键字的节点

    1. //删除第一次出现关键字为key的节点
    2.     public void remove(int key) {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             if(cur.val == key) {
    6.                 //处理头部问题
    7.                 if(cur == head) {
    8.                     head = head.next;
    9.                     if(head != null) {
    10.                         //防止只有一个节点
    11.                         head.pre = null;
    12.                     }
    13.                 }else {
    14.                     cur.pre.next = cur.next;
    15.                     if(cur.next != null) {
    16.                         //删除的不是尾巴节点
    17.                         cur.next.pre = cur.pre;
    18.                     }else {
    19.                         //删除的是尾巴节点
    20.                         last = cur.pre;
    21.                     }
    22.                 }
    23.                 return;
    24.             }
    25.             cur = cur.next;
    26.         }
    27.  
    28.         /*while (cur != null) {
    29.             if (cur.val == key) {
    30.                 cur.pre.next = cur.next;
    31.                 cur.pre = cur.next.pre;
    32.             }else {
    33.                 cur = cur.next;
    34.             }
    35.         }*/
    36.     }

    3.7删除所有出现关键字的节点

    1. //删除所有值为key的节点
    2.     public void removeAllKey(int key) {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             if(cur.val == key) {
    6.                 //处理头部问题
    7.                 if(cur == head) {
    8.                     head = head.next;
    9.                     if(head != null) {
    10.                         //防止只有一个节点
    11.                         head.pre = null;
    12.                     }
    13.                 }else {
    14.                     cur.pre.next = cur.next;
    15.                     if(cur.next != null) {
    16.                         //删除的不是尾巴节点
    17.                         cur.next.pre = cur.pre;
    18.                     }else {
    19.                         //删除的是尾巴节点
    20.                         last = cur.pre;
    21.                     }
    22.                 }
    23.  
    24.             }
    25.             cur = cur.next;
    26.         }
    27.     }

    3.8打印链表

    1.  //打印链表
    2.     public void display() {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             System.out.print(cur.val + " ");
    6.             cur = cur.next;
    7.         }
    8.         System.out.println();
    9.     }

    3.9清空链表

    1. //清空链表
    2.     public void clear() {
    3.         this.head = null;
    4.     }

    四、LinkedList的使用

    简单介绍

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

    下面是LinkedList的部分源码

     在集合框架中，LinkedList也实现了List接口

    说明：

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

     LinkedList的构造

    方法解释
    LinkedList()无参构造
    public LinkedList(Collection c)使用其他集合容器中元素构造List

    LinkedList的一些常用方法

    方法解释
    boolean add(E e)尾插e
    void add(int index, E element)将 e 插入到 index 位置
    boolean addAll(Collection 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 subList(int fromIndex, int toIndex)截取部分 list

    注意事项

    1、下图是add方法的源码，可以看到源码采用的是尾插

    五、ArrayList和LinkedList的区别

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

  • 相关阅读:
    3、Kafka进阶提升-消费者
    前端埋点上报的几种方式
    第三方代开的微信小程序更换管理员
    【python】什么是网络爬虫？
    标准I/O和系统I/O的本质区别
    openjdk和oracle jdk的区别
    代码随想录——图论一刷day05
    做推特群发群推“三不要怕”
    小程序与公众号：编程的异同
    node_exporter无法启动处理
  • 原文地址：https://blog.csdn.net/qq_52592775/article/details/126001631