Java链表

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

文章目录

前言

承接上文顺序表，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。本文将记录Java链表的学习过程，链表的概念以及链表的实现。

一、链表

1.1链表的概念及结构

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

 

 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向


2. 带头或者不带头
 

3. 循环或者非循环
 

虽然有这么多的链表的结构，但是我们重点掌握两种:
无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。


无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

 

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

2.1无头单向非循环链表部分函数

// 1、无头单向非循环链表实现
public class SingleLinkedList {
    static class Node{
        public int val;
        public Node next;
        public Node(int val){
            this.val =val;
        }
    }
    //定义一个头指针用于指向第一个元素的地址
    Node head;
    //头插法
    public void addFirst(int data) {}

    //尾插法
    public void addLast(int data) {}

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

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        return false;
    }
    
    //删除第一次出现关键字为key的节点
    public void remove(int key) {
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
    }
    
    //得到单链表的长度
    public int size(){
        return -1;
    }
    
    public void clear() {}
}

2.2链表的插入

2.2.1头插法

public void addFirst(int data) {
        Node node = new Node(data);
        node.next = head;
        head = node;
    }

2.2.2尾插法 

public void addLast(int data) {
        Node node = new Node(data);
        //尾插法需要判断头节点是否为空，不然会空指针异常
        if (head == null) {
            head = node;
            return;
        }
        Node cur = head;
        //让cur指针指向最后一个元素方便插入
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

 2.2.3任意位置的插入

    public void addIndex(int index, int data) {
        Node cur = head;
        //首位置就是头插法
        if (index <= 1) {
            addFirst(data);
            return;
        }
        //末位置就是尾插法
        if (index >= size()) {
            addLast(data);
            return;
        }
        //这里选择的是在哪一个位置
        while (index > 2) {
            cur = cur.next;
            index--;
        }
        Node node = new Node(data);
        node.next = cur.next;
        cur.next = node;
    }

2.3 是否包含这个元素

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

2.4删除元素 

2.4.1删除特定的一个元素

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if (head == null) {
            return;
        }
        Node cur = head;
        //如果是第一个元素，直接头指针后移
        if (cur.val == key) {
            head = head.next;
            return;
        }
        //从第二个元素开始判断
        while (cur.next != null) {
            if (cur.next.val == key) {
                //直接跳过被删除的元素即可
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
        System.out.println("数据不存在！");
    }

2.4.2删除所有的特定元素

public void removeAllKey(int key){
        int len = size();
        if (head == null) {
            return;
        }
        Node cur = head.next;
        //用一个指针记录待删除的前一个元素地址，以免后面脱链
        Node pre = head;
        while(cur != null) {
            if (cur.val == key) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        if (head.val == key) {
            head = head.next;
        }
        //当数据没有减少说明没有删除，也就是没有这个数据
        if(len == size()) {
            System.out.println("没有这个数据！");
        }
    }

2.5获取链表的长度 

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

 

三、 无头双向链表实现过程

3.1无头双向链表部分函数

// 2、无头双向链表实现
public class MyLinkedList {
    //头插法
    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(){}
}

3.2双向链表的插入

3.2.1头插法

    //头插法
    public void addFirst(int data){
        Node node = new Node(data);
        if (head == null) {
            head = node;
            last = node;
            return;
        }
        node.next = head;
        head.prev = node;
        head = node;
    }

3.2.2尾插法

    public void addLast(int data){
        Node node = new Node(data);
        if (head == null) {
            head = node;
            last = node;
            return;
        }
        last.next = node;
        node.prev = last;
        last = node;
    }

3.2.3任意位置插入

    public void addIndex(int index,int data){
        if (index < 0 || index > size()) {
            System.out.println("插入位置错误！");
        }
        if (index == size()) {
            addLast(data);
        }
        if (index <= 1) {
            addFirst(data);
        }
        Node cur = head;
        while (index > 2) {
            index--;
            cur = cur.next;
        }
        Node node = new Node(data);
        node.next = cur.next;
        cur.next.prev = node;
        cur.next = node;
        node.prev = cur;
    }

3.3查找元素

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

3.4删除元素

3.4.1删除一个对应的元素

    public void remove(int key){
        int len = size();
        if (head == null) {
            return;
        }
        Node cur = head;
        while (cur != null) {
            if (cur.val == key) {
                //当要删除的元素是第一个元素时
                if (cur == head) {
                    //如果只有一个元素情况要考虑
                    if (head.next == null) {
                        head = null;
                        last =null;
                    } else {
                        head = head.next;
                        head.prev = null;
                    }
                    return;
                } else {
                    //删除的是最后一个元素
                    if (cur.next == head) {
                        last = last.prev;
                        cur.prev.next = null;
                    } else {
                        cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                    }
                    return;
                }
            }
            cur = cur.next;
        }
        if(len == size()) {
            System.out.println("没有该元素存在");
        }
    }

3.4.2 删除对应的所有元素

在3.4.1的基础上删掉return即可

    public void removeAllKey(int key){
        int len = size();
        if (head == null) {
            return;
        }
        Node cur = head;
        while (cur != null) {
            if (cur.val == key) {
                //当要删除的元素是第一个元素时
                if (cur == head) {
                    //如果只有一个元素情况要考虑
                    if (head.next == null) {
                        head = null;
                        last =null;
                    } else {
                        head = head.next;
                        head.prev = null;
                    }
                } else {
                    //删除的是最后一个元素
                    if (cur.next == head) {
                        last = last.prev;
                        cur.prev.next = null;
                    } else {
                        cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
        if(len == size()) {
            System.out.println("没有该元素存在");
        }
    }

3.5计算链表长度

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

3.6删除链表

    public void clear(){
        Node cur = head;
        //将每一个都释放掉（当然也可以直接暴力清除）
        while (cur != null) {
            //这里借用一个指针先记录cur的后一个元素，防止拖链
            Node curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
        head = null;
        last = null;
    }

 

四、LinkedList的使用

4.1基本使用

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);
}

4.2 常用方法

方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List<E> subList(int fromIndex, int toIndex)截取部分 list

五、ArrayList与LinkedList区别

不同点ArrayListLinkedList
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持：O(N)
头插需要搬移元素，效率低O(N)只需修改引用的指向，时间复杂度为O(1)
插入空间不够时需要扩容没有容量的概念
应用场景元素高效存储+频繁访问任意位置插入和删除频繁

总结

本文主要介绍了Java中链表的基本使用方法，并且介绍了Java中LinkedList常用的一些方法，同时实现了链表的部分重要的函数

Endeavor945
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA实现链表面试题
09-03
【JAVA实现链表面试题】是针对Java编程语言中链表数据结构的一系列经典面试题的详细解析。链表是一种常见的数据结构，它不依赖于数组的连续内存空间，由一系列节点构成，每个节点包含数据和指向下一个节点的引用。本...
Java数据结构篇之链表
MasterJundarj的博客
09-23 2718
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4187
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
2024年Java最新Java算法基础 - 单链表详解（文末有配套视频）(2)，2024Java面试题知识点总结
最新发布
2401_83977696的博客
05-05 993
由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档还有更多面试复习笔记分享如下本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取CustNode类里面维护一个顾客的属性，为了方便起见，就直接用public了，反正我们自己用用的，无所谓。步骤 3 排队打饭。
JAVA——链表
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
Java中的链表
weixin_52758364的博客
12-09 3342
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
JAVA基础-链表
lwxklts的博客
02-02 704
链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。链表在插入的时候速度较快，可以达到O(1)的复杂度，但是查找操作较慢，需要O(n)的时间，线性表和顺序表查找操作的时间复杂度分别是O(logn)和O(1)。链表的物理存储结构是非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接的次序实现的.利用尾节点last尾插法插入结点。先查找结点比对结点值再删除。在指定结点前添加结点。
java链表反转及排序
09-01
在“java链表反转及排序”这个主题中，我们将探讨如何在Java中实现单向链表的反转和排序。首先，我们创建一个链表节点类，包含数据和指向下一个节点的引用： ```java public class ListNode { int val; // 节点值 ...
Java链表元素查找实现原理实例解析
08-18
Java链表元素查找实现原理实例解析 Java链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。每一个链表都包含多个节点，节点又包含两个部分，一个是数据域...
Java链表（Linked List）基本原理与实现方法入门示例
08-19
Java链表（Linked List）基本原理与实现方法入门示例 Java链表（Linked List）是一种基础而且重要的数据结构，在Java程序设计中广泛应用。本文将对Java链表（Linked List）的基本原理与实现方法进行详细介绍，并...
java链表的程序
01-01
Java链表是一种基础且重要的数据结构，主要用于存储和管理动态数据集合。在Java中，有多种类型的链表，包括单链表、双链表和循环链表等。本程序可能是针对这些链表类型的一种实现，用于Java考试复习。在Java中，`...
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
Java中的链表实现介绍
cnds123的专栏
02-18 1569
Java中的链表实现介绍。本文仅以单链表为例介绍。采用两种方式实现：一、使用Java.util 包的LinkedList类实现；二、自定义实现类实现。
【Java】链表LinkedList
qq_61635026的博客
07-06 9207
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 925
Java算法链表的深究
Java数据结构和算法——链表
人在杰途的博客
03-26 675
在表头增加节点：删除节点：①、单向链表的具体实现//链表节点的个数//头节点size = 0;//链表的每个节点类//每个节点的数据//每个节点指向下一个节点的连接//在链表头添加元素}else{size++;return obj;//在链表头删除元素size--;return obj;//查找指定元素，找到了返回节点Node，找不到返回null}else{tempSize--;//删除指定的元素，删除成功返回true。
Java链表详解--通俗易懂(超详细,含源码)
热门推荐
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
Java数据结构之链表
qq_64580912的博客
10-27 2092
小结:1)链表是以节点的方式来存储2)每个节点包含data域, next域:指向下一个节点.3)如图:发现链表的各个节点不一定是连续存储.4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
java链表增加节点
11-27
Java链表增加节点可以使用头插法或尾插法。其中，头插法是将新节点插入到链表的头部，而尾插法则是将新节点插入到链表的尾部。 以下是Java链表头插法的实现代码： ```java public void addHead(Node node) { // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值