LinkedList与链表

已于 2023-06-14 20:17:33 修改
阅读量257 收藏
点赞数 1
分类专栏： 数据结构 文章标签： java
于 2022-07-10 14:25:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67683346/article/details/125704759
版权

目录

一、链表的概念结构

二、单向无头非循环链表的实现

三、双向无头非循环链表的实现 

四、LinedList的遍历

1、for循环遍历

2、for each遍历

3、使用迭代器正向遍历

4、使用迭代器反向遍历

五、ArrayList和LinedList的区别

1、存储空间

2、随机访问

3、从头插入元素

4、应用场景

一、链表的概念结构

链表：是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。

​

如上图，每一个节点都会存储下一个节点的地址，那么就可以通过当前节点访问下一个节点，这些节点在逻辑上是连续的，但是在物理上不一定连续，因为每次申请的空间可能连续，可能不连续。 

实际中，链表的结构非常多样：

1、单向或双向：

​

  2、带头或不带头：

​​

 3、循环或非循环：

​​

这些情况组合起来就有8种链表结构：

​我们常用的是单向不带头非循环链表和双向不带头链表。

二、单向无头非循环链表的实现

public class SingleList {
    private int usedSize;

    static class ListNode {
        public int val;
        public ListNode next;

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

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

    public void disPlay() {
        ListNode ret = this.head;
        while (ret != null) {
            System.out.print(ret.val + " ");
            ret = ret.next;
        }
    }
    //查看链表中是否包含key
    public boolean contains(int key) {
        ListNode ret = this.head;
        while (ret != null) {
            if (ret.val == key) {
                return true;
            }
            ret = ret.next;
        }
        return false;
    }

    public int size() {
        /*Node ret = this.head;
        int count = 0;
        while (ret != null){
            count++;
            ret = ret.next;
        }
        return count;*/
        return this.usedSize;
    }

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

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

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

    //任意位置插入
    public void addIndex(int index, int data) {
        checkIndex(index);
        if (index == 0) {
            addFirst(data);
        }
        if (index == usedSize) {
            addLast(data);
        }
        ListNode node = new ListNode(data);
        ListNode ret = head;
        for (int i = 0; i < index - 1; i++) {
            ret = ret.next;
        }
        node.next = ret.next;
        ret.next = node;
        usedSize++;
    }

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

    /**
     * 找到关键字key的前驱
     *
     * @param key
     * @return
     */
    private ListNode searchPrevOfKey(int key) {
        if (head == null) {
            return null;
        }
        ListNode cur = head;
        while (cur.next != null) {
            if (cur.next.val == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    //删除所有值为key的节点
    public void removeAllKey(int key) {
        if (head == null) {
            return;
        }
        ListNode prev = head;
        ListNode cur = prev.next;
        while (cur != null) {
            if (cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
                usedSize--;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        if (head.val == key) {
            head = head.next;
            usedSize--;
        }
    }
    //清空链表
    public void clear() {
        //this.head = null;
        ListNode cur = this.head;
        while (cur != null) {
            ListNode curNext = cur.next;
            cur.next = null;
            cur = curNext;
        }
        this.head = null;
    }
}

三、双向无头非循环链表的实现 

public class MyLinkedList {
    //节点
    public class ListNode{
        public int val;
        public ListNode next;
        public ListNode prev;//记录当前节点的前驱
        public ListNode(int data){
            this.val = data;
        }
    }
    public ListNode head;
    public ListNode last;
    //头插法
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        if(this.head == null){
            this.head = node;
            this.last = node;
        }else {
            this.head.prev = node;
            node.next = head;
            head = node;
        }
    }
    //尾插法
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(this.head == null){
            this.head = node;
            this.last = node;
        }else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }
    private void checkIndex(int index){
        if(index<0 || index>size()){
            throw new RuntimeException("index坐标不合法");
        }
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        checkIndex(index);
        if(index == 0 || this.head == null){
            addFirst(data);
            return;
        }
        if(index == size()){
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = this.head;
        for (int i = 1; i < index; i++) {
            cur = cur.next;
        }
        node.next = cur.next;
        node.prev = cur;
        cur.next.prev = node;
        cur.next = node;
    }
    //查找是否包含关键字key是否在双链表当中
    public boolean contains(int key){
        ListNode cur = this.head;
        while (cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur = this.head;
        while (cur != null){
            if(cur.val == key){
                if(cur == this.head){
                    //删除头节点
                    this.head = this.head.next;
                    if(this.head != null){
                        //只有一个节点的情况
                        this.head.prev = null;
                    }
                }else {
                    //删除中间节点
                    cur.prev.next = cur.next;
                    if(cur != this.last){
                        cur.next.prev = cur.prev;
                    }else {
                        //删除尾结点
                        this.last = cur.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur = this.head;
        while (cur != null){
            if(cur.val == key){
                if(cur == this.head){
                    //删除头节点
                    this.head = this.head.next;
                    if(this.head != null){
                        //只有一个节点的情况
                        this.head.prev = null;
                    }
                }else {
                    //删除中间节点
                    cur.prev.next = cur.next;
                    if(cur != this.last){
                        cur.next.prev = cur.prev;
                    }else {
                        //删除尾结点
                        this.last = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }
    //得到双链表的长度
    public int size(){
        ListNode cur = head;
        int count = 0;
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }
    public void display(){
        ListNode cur = head;
        while (cur != null){
            System.out.println(cur.val);
            cur = cur.next;
        }
    }
    public void clear(){
        /*this.head = null;
        this.last = null;*/
        ListNode cur = this.head;
        while (cur != null){
            if(cur.next != null) {
                cur = cur.next;
                cur.prev.next = null;
                if(cur.prev != null) {
                    //处理头节点
                    cur.prev.prev = null;
                }
            }else {
                //处理尾巴节点
                this.head = null;
                this.last = null;
                cur = null;
            }
        }
    }
}

四、LinedList的遍历

1、for循环遍历

2、for each遍历

3、使用迭代器正向遍历

4、使用迭代器反向遍历

五、ArrayList和LinedList的区别

1、存储空间

ArrayList在逻辑上是连续的，并且在物理内存上也是连续存储的；

LinkedList在逻辑上是连续的，但是在物理内存上不一定是连续的。

2、随机访问

ArrayList支持随机访问，并且时间复杂度为O(1)；

LinkedList不支持随机访问，访问链表内元素需要遍历整个链表，时间复杂度为O(N)。

3、从头插入元素

ArrayList使用头插法效率较低，需要搬移元素，如果空间不够，还需要扩容，时间复杂度为O(N)；

LinkedList只需修改引用的指向，没有容量的概念，不需要扩容，时间复杂度为O(1)。

4、应用场景

当元素需要频繁访问或高效存储时，ArrayList更适用；

当元素需要频繁删除或从任意位置插入时，LinkedList更适用；

吃点橘子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linkedlist_链表_
10-02
总结来说，"linkedlist_链表_"主题深入讲解了链表的基础概念，包括单链表和双链表的创建、节点的添加与删除、链表的逆序操作以及遍历技巧。掌握这些知识对于理解和应用数据结构，尤其是处理动态数据集合，具有重要...
数据结构-线性表-链表
h1192341606的博客
04-28 627
链表 概念 链表（Linked list）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中的每个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 存储结构 相比于数组，链表是一种稍微复杂一点的数据结构。对于这两个非常基础、非常常用的数据结构，我...
可随机访问的双向链表(C#实现)
邓汪涛的博客
07-24 1099
可随机访问的双向链表(C#实现) 引用名称空间 using System; namespace MyTest { 声明结点的类 //节点 class Node<T> { public T value; //值域 //指针域 public Node<T> prev; //前驱指针 public Node<T> next; //后继指针 public Node()
49- LinkedList 集合
记录java学习日常~
09-13 72
除了继承自List接口和Deque接口的方法外，LinkedList还提供了一些与链表相关的操作，如在链表的开头或末尾添加或删除元素、获取链表的第一个或最后一个元素等。LinkedList集合是Java集合框架提供的一种基于链表实现的集合类。它实现了List接口和Deque接口，并且可以用作栈（先进后出）或队列（先进先出）。LinkedList集合适合于需要频繁的插入和删除操作的场景，并且不需要高效的随机访问。
leetcode 146 LRU缓存 链表随机访问
qq_39678022的博客
07-23 318
LRU缓存机制就是存键值对，但是会更新，并且要删除最不经常使用的，比如最多开10个应用，开第11个就必须删掉一个最久没用的。 要求实现get和put两个O(1)操作，实现办法只有链表加随机访问，否则无法做O(1)的移位。 如何实现链表随机访问？要调用c++里的list（双向链表），同时用一个map来做key到迭代器的键值对。 注意：list和双端队列函数差不多，可以直接有一个移动的操作，splice，这个比较新。 class LRUCache { typedef pair<int, int> .
数据结构——链表
Xyzone007的博客
08-05 4495
数据结构——链表 对于c语言而言，链表中的元素在内存中不是连续存储的，栈和队列在内存中是连续存储的。 链表中需要有一个头指针。头指针对与链表而言十分重要。可以通过头指针找到链表中的第一个节点。 每一个节点可以分为两个部分，一部分存放节点对应的指针，即指针域，另一部分存放数据，即数据域。 每一个节点的指针域的指针数据指向下一个结点开始的地址。通过这种方式将链表的所有的节点连接起来。最后一个节点的指针域为空NULL。 链表不支持随机访问，链表在内存中并不是连续存在的，而是随机分布的，找到下一个节点的指针就必
LinkedList:链表
07-03
本篇文章将深入探讨链表的概念、Java中的LinkedList类以及其常用方法。 ### 链表概念 链表不同于数组，它不连续存储元素。每个元素（节点）包含两部分：数据和指向下一个节点的引用。这种存储方式使得在链表中插入...
LinkedList:链表算法
04-13
链表 链表算法 链表算法的实现，该算法从stdin读取用户命令并根据用户指令命令在链表上运行特定功能，例如：PUT n，GET n，LIST，FIRST，LAST，SORT，CLEAR，REMOVE n，EXIT，其中： PUT n-将一个整数n插入到链表中...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
LinkedList
最新发布
qq_52234241的博客
12-06 66
ArrayList是一个基于双向链表实现的集合，由于无法对元素进行随机访问，LinkedList仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1)，其他情况增删元素需要移动到指定位置，平均时间复杂度都是 O(n)。ArrayList的性能通常会比LinkedList更好，所以不要下意识地认为LinkedList作为链表就最适合元素增删的场景。
源码学习——LinkedList
绿水本无忧
08-23 172
源码学习——ArrayList 文章目录前言继承关系内部节点类成员变量构造方法添加添加到末尾插入到指定位置添加一个集合删除删除一个元素查看修改双端队列相关LinkedList 和 ArrayList 的区别 前言 将常用的步骤解释的较为详尽易懂，若有错误麻烦指正。个人认为甚至些许啰嗦，建议有基础的同学直接看源码，源码更为直接了当易懂，且不会产生语句上的歧义。 继承关系 UML 图示 实现 List 接口，属于列表类 实现 Deque 接口，属于一个双端队列 实现 Cloneable 接口，可以重写 Ob
刷题日志——链表篇(上)
m0_56620669的博客
12-04 825
这篇博客就是总结以下自己刷力扣链表简单题的错误点与想法。 1.合并两个有序链表 第一次的有错想法： class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode dummy = new ListNode(-1); ListNode tmp = dummy; while (l1 != null || l2 != null){ ..
【数据结构】LinkedList与链表
Living_Amethyst的博客
05-11 623
【引言】 上篇文章我们介绍了ArrayList的使用以及它的一些相关知识，还模拟实现了简单的顺序表 我们在这个过程中，有了以下的思考：ArrayList的底层是使用数组来存储元素的 这就导致当ArrayList的任意位置插入或删除元素时，就需要将后续元素整体向后移或者向前移，所以时间复杂度为O(N) 因此ArrayList不适合做任意位置插入和删除比较多的场景 所以，Java集合中又引入了LinkedList，即链表结构 1.链表 1.1链表的概念和结构 ......
从Java源码上分析为什么LinkedList随机访问比顺序访问要慢这么多？
鳄鱼儿
07-05 519
随机访问使用get方法，从源码中我们可以得知，每次都遍历找到该元素位置再返回，当我们需要遍历一次，其实会遍历很多次，做了重复性工作。源码 从迭代器源码中我们得知，在进行顺序访问时，只在第一次，index=0时进行了一个折半判断，此后按照顺序依次向后传递获取元素，实际只进行了一次遍历过程。由此可见，的顺序遍历比随机遍历快很多。...
LinkedList为什么不支持高效的随机访问
yzwfeng的专栏
01-11 768
那关键的问题我想随即访问一个元素，比如说有1W个元素LinkedList，你现在要访问第9999个元素，他是这么访问的，他先将第一个元素拿出来看下不是，然后找A的引用，再将B拿出来还是不是，然后再找，他就这样一直找啊找，找啊找，在他找第9998还是不是在把9998的引用指向的元素拿出，oh year找到了，然后给你。LinkedList是由链表实现的，针对元素的插入删除比较高效，但是不支持随机访问，只能一个元素一个元素的遍历，数组根据下标支持随机访问。因此，获取最后一个元素比第一个元素花费更多的时间。
链表知识简单总结
学习博客，一路同行
01-13 2685
常见链表知识 链表（Linked List）：一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。 分为：双向链表、循环链表。实际做题常见的还是单链表非循环的 链表排序 对于链表排序而言，因为链表不支持随机访问，访问链表后面的节点只能依靠 next 指针从头部顺序遍历，所以相对于数组排序问题来说，链表排序问题会更加复杂一点。 适合链表的排序算法：冒泡排序、选择排序、插入排序、归并排序、快速排序、计数排序、桶排序、基数排序。 希尔排序为什么不适合
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1329
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
【代码随想录】链表——“链表”相关题目
m0_51660741的博客
04-15 1090
移除一个节点之后，要养成手动清理内存的习惯。 203. 移除链表元素 设置一个虚拟头结点在进行移除节点操作 ListNode* dummy=new ListNode(0);//设置一个虚拟头结点 dummy->next=head;//将虚拟头结点指向head ListNode* cur=dummy;//cur指针指向虚拟头结点 释放多余的节点 class Solution { public: ListNode* removeElements(ListNode* head, .
0牛客网 反转链表
31楼下小黑的博客
09-11 138
反转链表 题目描述:输入一个链表，反转链表后，输出新链表的表头。 首先明确一点，ListNode pre = head;ListNode cur = head；pre,cur只是引用变量不是对象本身！，当pre发生变化，cur也会发生变化，因为他们两指向的是同一个对象。（我刚开始以为pre,cur互补不影响，结果错了） 思路 已知pre->cur->… 要想变成…->cur->pre，即让pre的后面的结点反过来指向它 想做到这一点首先一定要保存cur后面那个结点，不然cur.nex

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吃点橘子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值