Java数据结构-LinkedList与链表

最新推荐文章于 2024-09-04 14:03:13 发布
最新推荐文章于 2024-09-04 14:03:13 发布
阅读量35 收藏
点赞数
分类专栏： Java数据结构 文章标签： 数据结构 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45965652/article/details/134772846
版权
本文详细介绍了Java中的链表（ArrayList和LinkedList）概念、结构、实现以及它们在插入、删除操作上的性能差异，重点讲解了单链表和双向链表，并探讨了LinkedList在集合框架中的适用场景。
摘要由CSDN通过智能技术生成

文章目录

前言

本文用于对最近学习的Java中链表知识进行总结。

一、链表

1.1 ArrayList的缺陷

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

1.2 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。
在这里插入图片描述
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
（1）单向或者双向
在这里插入图片描述
（2）带头或者不带头
在这里插入图片描述
（3）循环或者非循环
在这里插入图片描述

重点掌握两种:
  无头单向非循环链表.
  无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

1.3 单链表的实现

public class MySingleList {

    private 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(12);
        ListNode node3 = new ListNode(12);
        ListNode node4 = new ListNode(12);

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

        head = node1;
    }

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

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

            }
            cur.next = node;

        }
    }

    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index, int data) {
        ListNode node = new ListNode(data);
        checkIndexAdd(index);
        if (index == 0) {
            addFirst(data);
            return true;
        }
        if (index == size()) {
            addLast(data);
        }
        int count = 0;
        ListNode cur = head;
        while (count != index - 1) {
            cur = cur.next;
        }
        node.next = cur.next;
        cur.next = node;
        return true;
    }

    private void checkIndexAdd(int index) {
        if (index < 0 || index > size()) {
            throw new MySingleListIndexOutOfException("任意位置插入的时候，index不合法！");
        }
    }

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

    }

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if (head == null) {
            return;
        }
        if (head.val == key) {
            head = head.next;
            return;
        }

        ListNode cur = head;
        while (cur.next != null) {
            if (cur.next.val == key) {
                ListNode del = cur.next;
                cur.next = del.next;
                return;
            }
            cur = cur.next;


        }

    }

    //删除所有值为key的节点
    public void removeAllKey(int key) {
        if (head == null) {
            return;
        }

        ListNode pre = head;
        ListNode cur = head.next;
        while (cur != null) {
            if (cur.val == key) {

                pre.next = cur.next;
                cur = cur.next;

            } else {
                pre = cur;
                cur = cur.next;

            }


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

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

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

    /**
     * 从指定节点开始打印
     */
    public void display(ListNode newHead) {

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

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

1.4 双向链表的实现

public class MyLinkedList {
    private static class ListNode {
        int val;
        ListNode next;
        ListNode pre;

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

    ListNode head;
    ListNode last;

    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
            last = node;
        } else {
            node.next = head;
            head.pre = node;
            head = node;
        }
    }

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

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

        if (index < 0 || index > size()) {
            throw new IndexOutException("index:" + index);
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }

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

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = 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) {
                    head = head.next;
                    //只有一个节点并且需要删除
                    if (head != null) {
                        head.pre = null;
                    } else {
                        last = null;
                    }
                } else {
                    //删除中间节点
                    cur.pre.next = cur.next;
                    //后一个节点是否为最后一个节点
                    if (cur.next != null) {
                        cur.next.pre = cur.pre;
                    } else {
                        last = last.pre;
                    }
                }
                return;
            }
            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;
                    //只有一个节点并且需要删除
                    if (head != null) {
                        head.pre = null;
                    } else {
                        last = null;
                    }
                } else {
                    //删除中间节点
                    cur.pre.next = cur.next;
                    //后一个节点是否为最后一个节点
                    if (cur.next != null) {
                        cur.next.pre = cur.pre;
                    } else {
                        last = last.pre;
                    }
                }

            }
            cur = cur.next;

        }
    }

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

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

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

二、LinkedList的使用

2.1 什么是LinkedList

LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
在集合框架中，LinkedList也实现了List接口，具体如下：
在这里插入图片描述

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

2.2 LinkedList的使用

（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） LinkedList的其他常用方法介绍
在这里插入图片描述

等等…
代码示例如下：

public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    list.add(1); // add(elem): 表示尾插
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);
    System.out.println(list.size());
    System.out.println(list);
// 在起始位置插入0
    list.add(0, 0); // add(index, elem): 在index位置插入元素elem
    System.out.println(list);
    list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
    list.removeFirst(); // removeFirst(): 删除第一个元素
    list.removeLast(); // removeLast(): 删除最后元素
    list.remove(1); // remove(index): 删除index位置的元素
    System.out.println(list);
// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
    if(!list.contains(1)){
        list.add(0, 1);
    }
    list.add(1);
    System.out.println(list);
    System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
    System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
    int elem = list.get(0); // get(index): 获取指定位置元素
    list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
    System.out.println(list);
// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
    List<Integer> copy = list.subList(0, 3);
    System.out.println(list);
    System.out.println(copy);
    list.clear(); // 将list中元素清空
    System.out.println(list.size());
}

（3）LinkedList的遍历
代码示例如下：

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

三、ArrayList和LinkedList的区别

在这里插入图片描述

炙热的大叔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构-LinkedList
诺浅的专栏
11-02 575
内部结构图实现原理LinkedList内部维护着一个Node<E>，其中E为你的类型，Node<E>包含着3个属性E item（类型），Node<E> next（下一个元素），Node<E> prev（上一个元素），每个Node都持有上一个和下一个元素的引用（链表和链尾除外），所以是一个引用链表的结构。 这种结构在取值的时候由于要算引用，所以比较慢，但是在添加和删除的时候只要把对应的引用替换就可以
【Java数据结构】LinkedList-链表
Carefree_State的博客
03-13 1461
此文章详细讲解数据结构：链表，以模拟LinkedList的视角去研究链表，学习单链表以及双向链表的基础知识，后续我们可以靠这些知识，进攻更难的oj题，更特殊的链表类型~
Java基础--LinkedList类实现链表
weixin_67679565的博客
01-29 844
Java基础，链表基础，LinkedList类实现链表。
Java数据结构-链表与LinkedList
daweidi的博客
07-11 2007
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。LinkedList实现了List接口。LinkedList没有实现RandomAccess接口，因此不支持随机访问。LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O（1）方法解释尾插 e将 e 插入到 index 位置尾插 c 中的元素删除 index 位置元素。
数据结构之链表与Java中的LinkedList
Sakura_lht
09-11 271
链表 1.链表定义 链表是线性表的一种。 线性表的定义为：一种可以在任意位置进行插入和删除数据元素操作的，由n个相同类型数据元素a0,a1,a2,⋯ ,an−1a_{0},a_{1},a_{2},\cdots,a_{n-1}a0​,a1​,a2​,⋯,an−1​组成的线性结构。其数据元素满足除第一个元素和最后一个元素外，每个元素只有一个直接前驱和直接后继，第一个元素没有前驱元素，最后一个元素没有后...
数据结构 | 链表LinkedList(Java实现)
xxzaa的博客
04-19 495
链表（重要+困难） 对链表这种数据结构的理解 对引用和对象的理解
javalist源码-LinkedList-in-Java:链表的Java源代码实现
05-19
在Java编程语言中，`LinkedList`是`List`接口的一个实现，它提供了链表数据结构的支持。`LinkedList`类在`java.util`包中定义，主要用于存储和操作有序的元素集合。这个类允许我们在列表的任何位置进行插入和删除...
Java list列表- Linkedlist链表学习
weixin_53089473的博客
03-22 1404
（2 ）Linkedlist链表 对链表的理解： 链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 可以理解为站队时你手中拿着下个人唯一的学号 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 可以理解为站队时你手中有前一个人和后一个人的学号 而上一篇帖子中提到的Arraylist可以理解为站队时你只知道你站
java - 数据结构，双向链表 - LinkedList
ryy1999的博客
12-03 1103
无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表 总结：    单向链表在删除一个节点的时候，需要借助前驱节点，才能删除。双向链表删除节点，不需要借助前驱节点 因为双向链表，它存储前驱和后驱的节点的地址，它都知道。 另外双向链表会多一个引用last，这个引用永远指向此时链表的尾巴节点 head就是永远指向双向链表的头节点。 2.2、实现一个类，来表示双向链表 实现LinkedList中的所有方法 通过这些方法就可以操作链表 得到链表的长度 查找是否包含关键字key
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 999
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
浙大数据结构：01-复杂度2 Maximum Subsequence Sum
最新发布
qq_74924951的博客
09-04 380
【代码】浙大数据结构：01-复杂度2 Maximum Subsequence Sum。
浙大数据结构：01-复杂度1 最大子列和问题
qq_74924951的博客
09-04 170
我们假设最终结果为数组中间的一段，那么左边剩余的部分和右边剩余的部分和一定小于0，对答案没有贡献。使用在线处理，遍历数组，如果当前数组和小于0则抛弃，每次更新最大值。
二分查找效率提高的思路是什么
2301_80079026的博客
08-30 454
二分查找比如进行了n次，最后找到一个元素，从后往前，1乘以2就是上次二分查找所剩下的元素，以此类推，进行了n次，就是总共有2的n次个元素，总元素为m个，要是一个一个查找，则最多为m次，也就是2的n次等于m，效率也就变为了log以2为底m的对数。//这里不用(left+right)/2，防止left+right溢出
数据结构之最短路径
DKPT的博客
08-30 451
最短路径问题可以分为两类：1、单源最短路径：从图中一个指定的源点出发，求该源点到图中其他所有顶点的最短路径。2、多源最短路径：求图中任意两个顶点之间的最短路径。最短路径问题是图论中的一个重要问题，它有多种解决算法，如Dijkstra算法、Bellman-Ford算法和Floyd算法等。这些算法各有特点，适用于不同的场景和需求。在实际应用中，需要根据具体问题的特点和要求选择合适的算法。
Java算法之插入排序（Insertion Sort）
weixin_38959316的博客
08-29 3301
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
Redis八种数据结构简介
m0_67496588的博客
08-29 1188
Redis八种数据结构
【数据结构】二叉树之入门，树与二叉树的相关介绍
2301_80191662的博客
09-04 878
二叉树的入门介绍，介绍了树与二叉树的相关内容
Java-数据结构-ArrayList-练习 ψ(*｀ー´)ψ
2303_80388948的博客
09-01 453
OK，我们这次关于顺序表的练习就到这里就结束了，我们接下来介绍为了解决顺序表ArrayList 的缺陷方面，而出现的链表的介绍。让我们期待下次的见面吧！！！拜拜~~~t=N7T8。
数据结构——二叉树
2301_80401288的博客
08-29 847
数据结构——二叉树 求点赞收藏评论关注！！！ 十分感谢！！！
Java SE编程：LinkedList与链表数据结构解析
LinkedList是Java集合框架中的一个重要组件，对于理解和掌握Java数据结构和算法有着重要的作用。同时，JavaSE的学习涵盖了广泛的编程概念和技术，从基础的语法到高级的GUI编程和数据库交互，都是成为一个全面的Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值