【数据结构】LinkedList 链表

最新推荐文章于 2024-05-22 10:31:55 发布
最新推荐文章于 2024-05-22 10:31:55 发布
阅读量80 收藏
点赞数
分类专栏： 算法与数据结构 # 数据结构 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fisherish/article/details/121602451
版权

在这里插入图片描述

数据结构源码

实现类

public class LinkedList<E> {

    /**
     * 内部类，定义结点Node
     */
    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    /**
     * 维护字段
     */
    private Node dummyHead;  // 头结点

    private int size;  // 结点个数

    /**
     * 构造函数
     */
    public LinkedList() {
        dummyHead = new Node(null, null);
        size = 0;
    }

    /**
     * 获取链表中的元素个数
     */
    public int getSize() {
        return size;
    }

    /**
     * 返回链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 在链表的index位置添加新的元素e
     * 在链表中不是一个常用的操作
     */
    public void add(int index, E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node prev = dummyHead;
        for (int i = 0; i < index - 1; i++) {
            prev = prev.next;
        }

//            Node node = new Node(e);
//            node.next = prev.next;
//            prev.next = node;
        prev.next = new Node(e, prev.next);
        size++;
    }

    /**
     * 在链表头部添加新的元素e
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 在链表末位添加新的元素e
     */
    public void addLast(E e) {
        add(size, e);
    }

    /**
     * 获得链表的第index个元素
     * 在链表中不是一个常用操作
     */
    public E get(int index) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }

    /**
     * 获得链表的第一个元素
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 获得链表的最后一个元素
     */
    public E getLast() {
        return get(size - 1);
    }

    /**
     * 修改链表的第index个元素为e
     * 在链表中不是一个常用操作
     */
    public void set(int index, E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }

    /**
     * 查找链表中是否需有元素e
     */
    public boolean contains(E e) {
        Node cur = dummyHead.next;

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

    /**
     * 从链表中删除index位置的元素，返回删除的元素
     * 在链表中不是一个常用的操作
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }

        Node resNode = prev.next;
        prev.next = resNode.next;
        resNode.next = null;
        size--;

        return resNode.e;
    }

    /**
     * 从链表中删除第一个元素，返回删除的元素
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 从链表中删除最后一个元素，返回删除的元素
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node cur = dummyHead.next;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");

        return res.toString();
    }

    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < 5; i++) {
            linkedList.addFirst(i);
        }

        linkedList.add(2, 666);
        System.out.println(linkedList);

        linkedList.remove(2);
        System.out.println(linkedList);

        linkedList.removeFirst();
        System.out.println(linkedList);

        linkedList.removeLast();
        System.out.println(linkedList);

    }
}

数据结构拆解

维护字段和内部类

    /**
     * 内部类，定义结点Node
     */
    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }


    /**
     * 维护字段
     */
    private Node dummyHead;  // 头结点

    private int size;  // 结点个数

构造函数

    /**
     * 构造函数
     */
    public LinkedList() {
        dummyHead = new Node(null, null);
        size = 0;
    }

增

    /**
     * 在链表的index位置添加新的元素e
     * 在链表中不是一个常用的操作
     */
    public void add(int index, E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node prev = dummyHead;
        for (int i = 0; i < index - 1; i++) {
            prev = prev.next;
        }

//            Node node = new Node(e);
//            node.next = prev.next;
//            prev.next = node;
        prev.next = new Node(e, prev.next);
        size++;
    }

    /**
     * 在链表头部添加新的元素e
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 在链表末位添加新的元素e
     */
    public void addLast(E e) {
        add(size, e);
    }

删


    /**
     * 从链表中删除index位置的元素，返回删除的元素
     * 在链表中不是一个常用的操作
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }

        Node resNode = prev.next;
        prev.next = resNode.next;
        resNode.next = null;
        size--;

        return resNode.e;
    }

    /**
     * 从链表中删除第一个元素，返回删除的元素
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 从链表中删除最后一个元素，返回删除的元素
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }

改


    /**
     * 修改链表的第index个元素为e
     * 在链表中不是一个常用操作
     */
    public void set(int index, E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }

查

    /**
     * 获取链表中的元素个数
     */
    public int getSize() {
        return size;
    }

    /**
     * 返回链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获得链表的第index个元素
     * 在链表中不是一个常用操作
     */
    public E get(int index) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }

    /**
     * 获得链表的第一个元素
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 获得链表的最后一个元素
     */
    public E getLast() {
        return get(size - 1);
    }



    /**
     * 查找链表中是否需有元素e
     */
    public boolean contains(E e) {
        Node cur = dummyHead.next;

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

测试用例


    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < 5; i++) {
            linkedList.addFirst(i);
        }

        linkedList.add(2, 666);
        System.out.println(linkedList);

        linkedList.remove(2);
        System.out.println(linkedList);

        linkedList.removeFirst();
        System.out.println(linkedList);

        linkedList.removeLast();
        System.out.println(linkedList);

    }
锥栗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python数据结构实战——链表(LinkedList)
12-21
链表中插入一堆数据2.8.完整代码+测试 1.定义结点类 class Node: def __init__(self,data=None,next=None): #传入值和指针 self.data = data #data赋值 self.next = next #next赋值 2.定义链表类 class ...
【数据结构】链表LinkedList
qq_61862008的博客
11-18 980
链表以及LinkedList介绍
数据结构之链表（LinkedList详解）
crazy_xieyi的博客
09-29 6928
LinkedList实现了List接口；LinkedList的底层使用了双向链表；LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问； LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)；ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。ArrayList顺序表在物理上和逻辑上都是连续的，但是在扩容的时候，可能会造成空间的浪费。而LinkedList在物理上不一定是连续的，在逻辑上是连续的。
LinkedList数据结构链表
qq_43012298的博客
02-16 714
LinkedList在Java中是一个实现了List和Deque接口的双向链表。它允许我们在列表的两端添加或删除元素，同时也支持在列表中间插入或移除元素。在分析LinkedListLinkedList。
数据结构：链表
梁辰兴的博客
09-17 317
链表（Linked List）是Java中常见的一种数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的引用。链表可以分为单向链表、双向链表和循环链表三种类型。简介链表是一种线性数据结构，用于存储有序的元素集合。链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用（指针）。链表中的元素可以通过遍历链表来访问，每个节点都有一个指向下一个节点的引用，直到达到链表的末尾。链表可以分为单向链表、双向链表和循环链表三种类型。
数据结构之链表
喜欢捣鼓各种技术
01-18 3867
数据结构之链表
【数据结构】链表
鑫仔的记忆
09-30 2000
链表
【数据结构】LinkedList与双向链表
qq_61903414的博客
12-20 1533
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
数据结构—LinkedList与链表
qq_61576108的博客
11-12 1373
链表是一种存储结构，数据元素的是通过链表中的次序实现的data表示数据；next表示指针，它总是指向自身的下一个结点，对于只有一个结点的存在，这个next指针则永远指向自身，对于一个链表的尾部结点，next永远指向开头。实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：1.2.3.LinkedList的底层是，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
数据结构之LinkedList与链表
tl2267190799的博客
10-26 166
数据结构之链表
数据结构——链表（Linked List）
热门推荐
jishuxhengjiu的博客
08-31 1万+
使用单向环形链表解决Josephu问题，用不带头结点的单向循环链表先构成一个有n个节点的链表，然后由k节点起从1开始计数，直到第m时，对应节点删除，然后从被删除的下一个节点开始从1开始计数，直到最后一个节点被删除结束算法。2.temp.next = temp.next.next，也就是说需要删除节点的前一个节点本来指向的是删除节点，然后我们使其指向删除节点的下一个节点，直接跳过删除节点，这样该节点也就相当于被删除了。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。1.单链表是以节点的方式来存储的。.
【Java演示】什么是链表？数据结构（三）
01-20
专栏《两周干掉数据结构》 本博文的大部分插图来自于《漫画算法——小灰》，也复制了该书部分文字 我加了一些自己的总结、代码（我代码实现是参考了本书以及java自带LinkedList的源代码） 我发现本书有关链表的代码...
Python数据结构与算法之列表（链表，linked list）简单实现
09-21
主要介绍了Python数据结构与算法之列表（链表，linked list）简单实现，具有一定参考价值，需要的朋友可以了解下。
链表+泛型+反射实现自定义的LinkedList集合类
09-11
该资源利用基础的链表结构，结合泛型和反射的知识点，实现重写LinkedList集合类，可以存放任意类型数据。比较推荐对Java有稳固基础的同学来阅读，为了方便阅读，代码的注释写的非常的清楚
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
04-18
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
[每日一题]169：找出最大的可达成数字
AngelDg的博客
05-21 326
题目要求得一个最大的整数 x，使其在不超过 t 次操作内变成与 num 相等的数字。每次操作可以选择将 x 增加或减少 1，同时可以选择将 num 增加或减少 1。返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。给你两个整数 num 和 t。
双非二本找工作前的准备day28
m0_61724447的博客
05-20 731
每天复习代码随想录上的题目2-3道算法（时间充足可以继续）
【代码随想录】【算法训练营】【第15天】 [102]二叉树的层序遍历 [226]翻转二叉树 [101]对称二叉树
最新发布
weixin_54954007的博客
05-22 407
思路及算法思维，指路。题目来自。day 15，一周中最困难的周三~
代码随想录算法训练营第14天 |● 理论基础 ● 递归遍历 ● 迭代遍历 ● 统一迭代
Calliops的博客
05-21 483
理论基础需要了解 二叉树的种类，存储方式，遍历方式 以及二叉树的定义记录我容易忘记的点题目一半都是用链式存储来做，但是可以稍微了解一下顺序存储定义的代码晚上无论如何也要把实习简历写一半。所以不磕了。
数据结构单向链表插入代码
03-26
`LinkedList` 类包含 `insert()` 方法，用于将指定的数据插入到链表的末尾。`display()` 方法则遍历整个链表并打印每个节点的值。 在 `insert()` 方法中，首先创建一个新节点 `new_node`，然后检查链表是否为空。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

锥栗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值