Java数据结构链表(LinkedList详解)

最新推荐文章于 2024-10-06 07:30:01 发布
最新推荐文章于 2024-10-06 07:30:01 发布
阅读量955 收藏 20
点赞数 9
文章标签： 数据结构 java 链表 前端 笔记 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75235246/article/details/142603975
版权

前言：

        Java数据结构链表部分和顺序表有所相似：

        首先都扩展了接口List，List里面的方法都会在LinkedList中重写。

        其次都可以实现数据的增删查改等基础功能。

        当然ArrayList相较于LinkedList有一定的缺陷，比如果在中间位置插入数据，在中间位置删除数据都比较麻烦，需要移动大量数据！LinkedList可以有效地解决移动数据的难题。

        当然LinkedList也有自我的缺陷(在C语言阶段已经详细研究，大家可以翻看之前的博客)，接下来就一起用Java的目光探究LinkedList。

自我实现MyLinkedList：

        由于之前在C预研阶段已经实现过链表，可以翻看之前的内容仔细了解，接下来直接上代码：

无头单向不循环链表：

Ilist接口：

public interface IList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void clear();
    public void display();
}

MyLinkedList类：

    public void addIndex(int index, int data) throws IndexExpection{
        if(index < 0||index>size()) {
            throw new IndexExpection("非法访问");
        }
        ListNode cur = head;
        if(head == null) {
            head = new ListNode(data);
            return ;
        }
        if(index == 0) {
            addFirst(data);
            return ;
        }
        if(index == size()) {
            addLast(data);
            return ;
        }
        while(index-1 != 0) {
            index--;
            cur = cur.next;
        }
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
    }

    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null) {
            if(cur.val == key) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void remove(int key) {
        if(head == null) {
            return ;
        }
    ListNode cur = head;
    if(cur.val == key) {
        head = head.next;
    }
    while(cur.next != null) {
        if(cur.next.val == key) {
            cur = cur.next.next;
            return ;
        }
    }
    if(cur.val == key) {
        cur = cur.next;
    }
    }

    @Override
    public void removeAllKey(int key) {
        if(head == null) {
            return ;
        }
        ListNode cur = head;
        if(cur.val == key) {
            head = head.next;
        }
        while(cur.next != null) {
            if(cur.next.val == key) {
                cur = cur.next.next;
            }
        }
        if(cur.val == key) {
            cur = cur.next;
        }
    }

    @Override
    public int size() {
        int num = 0;
        ListNode cur = head;
        while(cur != null) {
            num++;
            cur = cur.next;
        }
        return num;
    }

    @Override
    public void clear() {
    head = null;
    }

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

但是这里与Java中给的LinkedList有所不同，不在什么地方？

Java中的LinkedList是一个无头双向不循环链表，所以此时我们还需要进行一个改进。

无头双向不循环链表：

直接上代码：

package LinkedDemo;

/**
 * Created with IntelliJ IDEA.
 * Description:无头双向不循环
 * User: 29980
 * Date: 2024-09-29
 * Time: 12:21
 */
public class MyLinkedList implements IList{
    static class ListNode {
        private int val;
        private ListNode prev;
        private ListNode next;
        public ListNode(int data){
            this.val = data;
        }
    }
    private ListNode head;
    private ListNode last;
    @Override
    public void addFirst(int data) {
    ListNode node = new ListNode(data);
    if(head == null) {
        head = last = node;
    }else {
     node.next = head;
     head.prev = node;
     head = node;
    }
    }

    @Override
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if(head == null) {
            last = head = node;
        }
        //ListNode cur = head;
//        while(cur.next != null) {
//            cur = cur.next;
//        }
//        cur.next = node;
//        node.prev = cur;
       node.prev = last.prev;
        last = node;
    }

    @Override
    public void addIndex(int index, int data) {
        ListNode node = new ListNode(data);
        if(head == null) {
            head = node;
            return ;
        }
        if(index == 0) {
            addFirst(data);
            return ;
        }
        if(index == size()) {
            addLast(data);
            return ;
        }
        ListNode cur = head;
        while(index != 0) {
            cur = cur.next;
            index--;
        }
        node.next = cur;
        node.prev = cur.prev;
        cur.prev = node;
    }

    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null) {
            if(cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    @Override
    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.prev = null;
                    }else  {
                        last = null;
                    }
                }else {
                    cur.next.prev = cur.prev;
                    if(cur.next != null) {
                        cur.prev = cur.next;
                    }else {
                        last = last.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }

    @Override
    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.prev = null;
                    }else  {
                        last = null;
                    }
                }else {
                    cur.next.prev = cur.prev;
                    if(cur.next != null) {
                        cur.prev = cur.next;
                    }else {
                        last = last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

    @Override
    public int size() {
        ListNode cur = head;
        int num = 0;
        while(cur != null) {
            num++;
            cur = cur.next;
        }
        return num;
    }

    @Override
    public void display() {
        ListNode cur = head;
    for(int i = 0;i<size();i++) {
        System.out.print(cur.val+" ");
        cur = cur.next;
    }
    }

    @Override
       public void clear() {
    ListNode cur = head;
    while(cur != null) {
        ListNode tmp = cur.next;
        cur.next = null;
        cur.prev = null;
        cur = tmp;
    }
    head = last = null;
    }
}

LinkedList的使用：

        当然我们的核心还是在如何使用Java给定的LinkedList，首先我们再根据一下图片分析一次：

       

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

LinkedList的构造方法：

LinkedList的构造方法有以下两种：

一个是无参构造，另一个大家应该很少见是有参数，这个参数是Collection<?extends E> c ,是什么意思呢？

第一：两个类必须都是实现了Collection接口的。

第二：两个类<>里面的参数必须满足继承关系。

例如：
 

 public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        List<Object> list2 = new LinkedList<>(list1);
        System.out.println(list2);
    }

LinkedList遍历的方式：

        遍历LinkedLisst的方式有三种：

 方式一：foreach打印

//第一种foreach遍历
        for (int x:list) {
            System.out.print(x+" ");
        }
        System.out.println();

方式二：利用迭代器正向打印

       ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()) {
            System.out.print(it.next()+" ");
        }
        System.out.println();

方式三：利用反向迭代器打印：

        ListIterator<Integer> it1 = list.listIterator(list.size());
        while(it1.hasPrevious()) {
            System.out.print(it1.previous()+" ");
        }

打印结果如下：

多敲代码防脱发
关注
【数据结构】链表LinkedList
qq_61862008的博客
11-18 1120
链表以及LinkedList介绍
数据结构之双向链表详解
小源_ 的博客
12-20 3589
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
【数据结构】链表（LinkedList）详解
flmz_Kk的博客
07-15 3523
使用Java实现链表的创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作
数据结构之链表（LinkedList详解）
crazy_xieyi的博客
09-29 9075
LinkedList实现了List接口；LinkedList的底层使用了双向链表；LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问； LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)；ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。ArrayList顺序表在物理上和逻辑上都是连续的，但是在扩容的时候，可能会造成空间的浪费。而LinkedList在物理上不一定是连续的，在逻辑上是连续的。
【数据结构Java版】LinkedList与链表
m0_63372226的博客
10-19 803
一、什么是LinkedList二、LinkedList的模拟实现（1）合法LinkedList的要求（2）LinkedList实现的内容1.结点个数2.链表尾插元素3.链表头插元素4.指定下标插入元素5.删除指定下标结点6.删除指定元素7.获取指定下标元素8.设置指定下标元素9.从前往后获取指定元素下标10.从后往前获取指定元素下标11.判断是否包含指定元素12.清空链表13.判断链表是否为空三、LinkedList的使用（1）LinkedList的构造四、ArrayList与LinkedList的比较
Java版的数据结构——链表
ANNE_fly的博客
09-12 1298
LinkedList的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。【说明】实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess（该接口是实现随机访问）接口，因此LinkedList不支持随机访问。
Java数据结构之链表案例详解
weixin_63645714的博客
09-27 153
链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。每个节点相互连接形成链表，链表的头节点指向链表的第一个节点，尾节点指向链表的最后一个节点。在上面的链表类中，StudentNode是链表的节点类，包含一个学生对象和一个指向下一个节点的指针。如果要删除的节点是头节点，则将头节点改为下一个节点。否则遍历链表找到要删除的节点的前一个节点，将它的指针指向要删除的节点的下一个节点。在add方法中，先判断链表是否为空，如果是，则将第一个节点设置为添加的节点；
【Java数据结构】详解LinkedList与链表（二)
Easonmax的博客
06-01 1069
所以对于这10个面试题我们就讲述清楚了，并且我还把其中的部分题目当作特殊方法加入到模拟的无头单向非循环链表类中。无头单向非循环链表的模拟实现和其具体使用(此外还往模拟的链表内部添加了一些特殊方法)下篇文章将给大家带来LinkedList的模拟实现和具体使用。让我们共同学习，共同进步，为知识的海洋增添更多宝贵的财富！
Java数据结构之图详解
m0_63526467的博客
08-02 931
Java数据结构-图详解
Java 数据结构链表操作实现代码
09-01
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点间的引用关系连接。在Java中，我们可以使用对象来实现链表。链表分为单链表、循环链表和双向链表。 单链表是每个节点包含数据部分和指向下一...
java 实现双向链表实例详解
08-31
Java 实现双向链表实例详解是一种基本的数据结构，在 Java 中 LinkedList 已经实现了这种结构，但是作为开发者，也要拥有自己显示这种结构的能力。双向链表是一种动态的数据结构，它可以在内存中动态地分配和释放...
Java集合框架LinkedList详解及实例
08-30
《Java集合框架LinkedList详解及实例》 在Java编程语言中，集合框架是处理对象集合的重要工具，而LinkedList是这个框架中的一个重要组成部分。LinkedList是一种双端链表，它不仅提供了列表的基本功能，还支持高效的...
【笔记】数据结构12
m0_52024881的博客
09-29 548
看到的社区的一个知识总结，这里记录一下。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1131
本文介绍了数据结构中的AVL树，给出了C++的代码实现
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1262
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构之图（6）
2301_76246515的博客
10-05 743
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
数据结构篇（绪论）
wlcass zhengge blog
10-05 648
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
每日学习一个数据结构-默克尔树（Merkle Tree）
最新发布
wendao76的专栏
10-06 818
默克尔树（Merkle Tree），也称为哈希树，是一种二叉树结构，广泛应用于数据验证和完整性检查。它在区块链技术中尤为常见，但也有其他应用场景。默克尔树通过层次化的哈希结构，提供了高效、安全的数据完整性验证机制。它在区块链、分布式系统、网络安全等多个领域都有广泛的应用。理解默克尔树的工作原理和应用场景，有助于在实际开发中选择合适的工具和技术。希望这些解释对你有所帮助！如果有任何具体的问题或需要进一步的解释，请随时提问。
java数据结构链表详解
08-06
链表是一种常见的数据结构，用于存储一系列的元素。在Java中，链表可以使用LinkedList类来实现。下面是关于Java链表的详细解释： 链表由节点（Node）组成，每个节点包含两部分：数据域（存储元素的值）和指针域（指向下一个节点的指针）。链表的头节点是链表的起始点，尾节点是链表的结束点。 Java中的LinkedList类实现了List接口和Deque接口，因此可以用作列表和双端队列。LinkedList在内存中以链式结构存储元素，相邻元素通过节点的指针连接。 与数组相比，链表的一个优势是可以快速地插入和删除元素。由于链表中的元素在内存中不连续存储，所以插入和删除只需要改变指针的指向，而不需要移动其他元素。然而，链表的一个劣势是访问特定索引的元素比较慢，因为需要从头节点开始遍历链表。 下面是一些常用的操作示例： 1. 创建一个空链表： LinkedList<String> list = new LinkedList<>(); 2. 在链表末尾添加元素： list.add("A"); list.add("B"); list.add("C"); 3. 在指定位置插入元素： list.add(1, "D"); // 在索引为1的位置插入元素D 4. 获取链表的大小： int size = list.size(); 5. 获取指定索引位置的元素： String element = list.get(2); // 获取索引为2的元素 6. 修改指定索引位置的元素： list.set(0, "E"); // 将索引为0的元素修改为E 7. 删除指定索引位置的元素： list.remove(1); // 删除索引为1的元素 8. 遍历链表： for (String element : list) { System.out.println(element); } 需要注意的是，LinkedList类不是线程安全的，如果在多线程环境中使用链表，需要进行适当的同步处理。此外，由于链表中的元素不是连续存储，所以对于大量元素的访问和操作，可能会导致性能下降。在这种情况下，可以考虑使用ArrayList或其他更适合的数据结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值