二、Java 链表和 LinkedList

最新推荐文章于 2024-06-20 18:00:24 发布
最新推荐文章于 2024-06-20 18:00:24 发布
阅读量180 收藏 1
点赞数 2
文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kt_su/article/details/126492552
版权

文章目录

🚀 一、ArrayList 的缺点

上节我们学到顺序表，由于其底层是一段连续空间，ArrayList 任意位置插入或删除元素时，就需要将元素整体往前或后挪移，时间复杂度为 O( N )。因此 ArrayList 不适合进行任意位置插入或删除较多的场景。。

🚀 二、链表

🌟 2.1 链表的概念和结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。
在这里插入图片描述
❗ 注意：

  1. 从上图看出，链式结构在逻辑上是连续的，但是在物理上不一定连续。
  2. 节点的内存一般都是从堆上申请出来的。
  3. 从堆上申请的空间，两次申请的可能连续，也可能不连续。

在这里插入图片描述
在这里插入图片描述
我们重点掌握两种链表：

  1. 无头单向非循环链表：笔试中出场率高。
  2. 无头双向链表。

🌟 2.2 链表的实现

// 1. 无头单向非循环链表实现
public class MyLinkedList {
    static class ListNode{
        public int val;
        public ListNode next;

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

    // 存储当前链表的头节点的引用
    public ListNode head;

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

    /**
     * 头插法
     *  O(1)
     * @param data
     */
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

    /**
     * 尾插法
     * O( N )
     * @param data
     */
    public void addLast(int data){
        ListNode cur = head;
        ListNode node = new ListNode(data);
        if(head == null){
            head = node;
        }else{
            while(cur.next != null){
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    /**
     * 从任意位置插入，第一个节点下标为 0
     * @param index
     * @param data
     * @return
     */
    public void addIndex(int index, int data){
        checkIndex(index);
        if(index == 0){
            addFirst(data);
            return ;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndexNode(index);

        node.next = cur.next;
        cur.next = node;
    }

    /**
     * 找到 index 位置的节点
     * @param index
     * @return
     */
    private ListNode findIndexNode(int index){
        ListNode cur = head;
        while((index-1)>0){
            cur = cur.next;
            index--;
        }
        return cur;
    }

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

    /**
     * 获取链表长度
     * @return
     */
    public int size(){
        int cnt = 0;
        ListNode cur = head;
        while(cur != null){
            cnt++;
            cur = cur.next;
        }
        return cnt;
    }

    /**
     * 移除第一个为 key 的节点
     * @param key
     */
    public void remove(int key){
        if(head.val == key){
            head = head.next;
        }
        ListNode cur = searchPreOfKey(key);
        if(cur == null){
            return;
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

    /**
     * 找到关键字为 key 的节点的前一个节点
     * @param key
     */
    public ListNode searchPreOfKey(int key){
        ListNode cur = head;
        while(cur.next != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    /**
     * 移除所有关键字为 key 的节点
     * @param key
     */
    public void removeAll(int key){
        if(head == null){
            return;
        }
        ListNode pre = head;
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                pre.next = cur.next;
                cur = cur.next;
            }else{
                pre = cur;
                cur = cur.next;
            }
        }
    }
    
    /**
     * 清空链表
     */
    public void clear(){
        ListNode cur = head;
        while(cur != null){
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }

    /**
     * 查找单链表中是否包含 key
     * @param key
     * @return
     */
    public boolean contains(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
}

🚀 三、LinkedList 的使用

🌟 3.1 什么是 LinkedList

Java API 中的 LinkedList 的底层是双向链表结构，在任意位置插入或删除元素时，不需要搬移元素，效率比较高。
在这里插入图片描述
🔺说明:

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

🌟 3.2 LinkedList 的使用

常用方法

🌟 3.3 LinkedList 的遍历

  1. foreach 遍历。
  2. 迭代器遍历。
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);
    System.out.println(list.size());
    // 1. foreach 遍历
    for(Integer x : list){
        System.out.print(x + " ");
    }
    System.out.println();
    // 2. 使用迭代器
    Iterator it = list.listIterator();
    while(it.hasNext()){
        System.out.print(it.next() + " ");
    }
    System.out.println();
    // 3. 反向迭代器
    ListIterator<Integer> rit = list.listIterator(list.size());
    while(rit.hasPrevious()){
        System.out.print(rit.previous() + " ");
    }
    System.out.println();
}

🌟 3.4 LinkedList 的模拟实现

// 2. 无头双向链表实现
public class DLinkedList {
    static class ListNode{
        public int val;
        public ListNode next;
        public ListNode prev;

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

    // 当前链表的头尾节点
    public ListNode head;
    public ListNode last;

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

    /**
     * 头插法
     * @param data
     */
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        if(head == null){
            head = node;
            last = node;
        }else{
            node.next = head;
            head.prev = node;
            head = node;
        }
    }

    /**
     * 尾插法
     * @param data
     */
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(head == null){
            head = node;
            last = node;
        }else{
            last.next = node;
            node.prev = last;
            last = node;
        }
    }

    /**
     * 获取链表长度
     * @return
     */
    public int size(){
        int cnt = 0;
        ListNode cur = head;
        while(cur != null){
            cnt++;
            cur = cur.next;
        }
        return cnt;
    }

    /**
     * 在任意位置插入
     *
     * @param index
     * @param data
     */
    public void addIndex(int index, int data){
        // 1. 检查 index 合法性
        if(index < 0 || index > size()){
            throw new IndexOutOfBoundsException("index 位置不合法");
        }
        if(index == 0){
            addFirst(data);
        }
        else if(index == size()){
            addLast(data);
        }else{
            ListNode cur = findIndex(index);
            ListNode node = new ListNode(data);
            node.prev = cur.prev;
            cur.prev.next = node;
            node.next = cur;
            cur.prev = node;
        }
    }

    /**
     * 找到 index 位置的节点
     * @param index
     * @return
     */
    private ListNode findIndex(int index) {
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    /**
     *  判断是否存在 key 值
     * @param key
     * @return
     */
    public boolean contains(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    /**
     * 删除第一次出现关键字为 key 的节点
     * @param key
     */
    public void remove(int key){
        if(head.val == key){
            head.next.prev = null;
            head = head.next;
            return;
        }else{
            ListNode cur = head;
            while(cur != null){
                if(cur.val == key){
                    if(cur == last){
                        last.prev.next = null;
                        last = last.prev;
                        return;
                    }else{
                        cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                        return;
                    }
                }
                cur = cur.next;
            }
        }
    }

    /**
     * 删除所有值为 key 的节点
     * @param key
     */
    public void removeAll(int key){
        if(head.val == key){
            head.next.prev = null;
            head = head.next;
        }
        ListNode cur = head;
        while(cur != null) {
            if (cur.val == key) {
                if (cur == last) {
                    last.prev.next = null;
                    last = last.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 curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
        head = null;
        last = null;
    }
}

🚀 四、顺序表和链表的区别

首先是 java 内置的 ArrayList 和 LinkedList 的区别

在这里插入图片描述

顺序表和链表由于存储结构上的差异，导致它们具有不同的特点，适用于不同的场景。

4.1 存储结构

  • 顺序表存储数据，先预先申请一块足够大的存储空间，然后将数据按照次序逐一存储，数据之间紧密贴合。
  • 链表存储方式和顺序表截然不同，链表只有在存储数据时才申请存储空间，数据之间的逻辑依靠每个数据元素携带的指针维持，实际的物理结构并不相连。
    在这里插入图片描述

4.2 空间利用率

从空间利用率的角度上看，顺序表的空间利用率显然要比链表高。

这是因为，链表在存储数据时，每次只申请一个节点的空间，且空间的位置是随机的，这种方式会产生很多空间碎片，造成空间的浪费。

4.3 时间复杂度

解决不同类型的问题，顺序表和链表对应的时间复杂度也不相同。
如下两类问题：

  1. 主要进行元素访问操作，元素的插入、删除和移动较少时。
  2. 主要进行元素的插入、删除和移动，元素的访问很少时。
  1. 第一类问题适合使用顺序表。
    • 顺序表底层是数组，支持随机访问，可以直接通过下标访问元素，无需遍历整个表时间复杂度为 O( 1 ) 。
    • 链表中访问数据元素，只能从头到尾遍历节点，时间复杂度 O( N ) 。
  2. 第二类问题更适合使用链表。
    • 链表中元素之间的逻辑关系靠的是节点之间指针，在执行插入、删除和移动操作时，只需要改变相应节点的指针指向即可，无需移动大量元素，时间复杂度 O( 1 )。
    • 而顺序表中，插入、删除和移动数据可能会牵涉到大量元素的整体移动，因此时间复杂度至少为 O(n) 。
江初。
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java-链表结构、自己实现一个LinkedList
weixin_44900158的博客aa
09-16 301
1、什么是链表？ 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。 每一个链表都包含多个节点，每个节点又包含两部分，一部分是数据域（储存节点含有的元素），另一部分是引用域（储存下一个节点），当然如果是双向链表就有两个引用域(一个存储上一个节点地址另一个存储下一个节点地址)。 链表的理解示意图 双向链表的删除示意图 2、链表的特点是什么？ 获取数据麻烦，因为需要遍历查找，比数组慢。见下面node(int index)方...
java的单链表实现LinkList
qq_41648092的博客
03-16 527
1.首先有一个节点的实体类。 public class Node { private Object previous; private Object obj; private Object next; public Node(){ } public Node(Object previous, Object obj, Object next) { super(); thi...
Java集合类——LinkedList（单链表及双链表）
小小码农
12-29 1062
Java集合类——LinkedList（单链表及双链表）
Java实现ListNode和LinkedList
weixin_44616879的博客
05-29 527
Java实现ListNode和LinkedList
【数据结构】LinkedList与链表
Living_Amethyst的博客
05-11 612
【引言】 上篇文章我们介绍了ArrayList的使用以及它的一些相关知识，还模拟实现了简单的顺序表 我们在这个过程中，有了以下的思考：ArrayList的底层是使用数组来存储元素的 这就导致当ArrayList的任意位置插入或删除元素时，就需要将后续元素整体向后移或者向前移，所以时间复杂度为O(N) 因此ArrayList不适合做任意位置插入和删除比较多的场景 所以，Java集合中又引入了LinkedList，即链表结构 1.链表 1.1链表的概念和结构 ......
关于LinkedList和LinkedListNode
雍王爷的博客
03-22 1万+
1.概念：  List是数组链表 LinkedList是指针链表、双向链表 选择List还是LinkedList要看你的使用特点. 数组链表访问快,复杂度O(1),但是添加删除复杂度O(n) 指针链表访问复杂度是O(n),但是添加删除很快O(1) 2.含义 LinkedList集合类没有非泛型类的版本，它是一个双向链表，它的元素指向元素的前一个与后一个元素 链表的优点是：如果要
LinkedList:使用 Java 实现链表
06-13
链表 使用 Java 实现链表
Java 实例 - 在链表（LinkedList）的开头和结尾添加元素源代码-详细教程.zip
08-09
Java 实例 - 在链表（LinkedList）的开头和结尾添加元素源代码-详细教程.zip
Java中ArrayList和LinkedList区别
12-22
　1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 　2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 　3.对于新增和删除操作add和remove，...
测试ArrayList和LinkedList的add方法
03-17
测试ArrayList和LinkedList的add方法
JAVA链表的介绍（包含单项链表、双向链表）、LinkedList 与 ArrayList 比较、链表的基本操作、基本方法等
04-01
JAVA链表的介绍（包含单项链表、双向链表）、LinkedList 与 ArrayList 比较、链表的基本操作、基本方法等
java集合-LinkedList的使用
06-14
基于双向链表实现的列表，支持在任意位置的插入和删除操作。
linkedlistnode java_java数据结构之LinkedList
weixin_35950531的博客
02-26 524
//LinkedList源码 jdk版本1.8.0_121public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, java.io.Serializable{transient int size = 0;/*** 指向第一节点* first和last要么都为null，要么都...
java 中创建链表 ListNode
zlq_CSDN的博客
11-04 9625
class ListNode { 2 //为了方便,这两个变量都使用pub1ic, 3 //存放数据的变量,直接为int型 4 public int data; 5 //存放结点的变量,默认为nu11 6 public ListNode next; 7 //构造方法,在构造时就能够给data赋值 8 public ListNode () { ...
Java--链表ListNode
Lanly-Li的博客
07-28 4万+
今天我们来介绍一下Java中的链表，作者依旧尽量用白话解释，希望能帮到大家 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 上面是链表的定义，那么我们用通俗点的语言...
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
java链表ListNode
程序媛的博客
03-06 3万+
/** * 描述： 删除链表中等于给定值val的所有节点。 样例： 给出链表 1-&gt;2-&gt;3-&gt;3-&gt;4-&gt;5-&gt;3, 和 val = 3, 你需要返回删除3之后的链表：1-&gt;2-&gt;4-&gt;5。 分析： 1.首先判断head是不是空，为空就直接返回null 2.然后从head.next开始循环遍历，删除相等于val的元素 3.最后...
数据结构与算法-差分数组及应用
最新发布
qq_36115196的博客
06-20 716
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
java ArrayDeque和linkedlist
08-20
Java中的ArrayDeque和LinkedList都是实现了Queue接口的类，用于表示队列数据结构。它们之间有一些重要的区别。 ArrayDeque是基于数组的双端队列实现，可以在队列的两端进行添加和删除操作。它具有高效的插入和删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值