java的LinkedList

于 2024-10-09 20:22:44 发布
阅读量678 收藏 16
点赞数 14
分类专栏： Java 数据结构 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76124988/article/details/142667456
版权

java的LinkedList

什么是LinkedList

LinkedList的官方文档
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的结点中，然后通过引用将结点连接起来了，因此在任意位置插入或删除元素时，不需要搬移元素，效率比较高。
在这里插入图片描述
说明：

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

LinkedList的模拟实现

在这里插入图片描述

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

public class MyLinkedList implements IList{
        static class ListNode{
        public int val;
        public ListNode prev;
        public ListNode next;

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


    public ListNode head;
    public ListNode last;
    
    @Override
    public void addFirst(int data) {
        
    }

    @Override
    public void addLast(int data) {

    }

    @Override
    public void addIndex(int index, int data) {

    }

    @Override
    public boolean contains(int key) {
        return false;
    }

    @Override
    public void remove(int key) {

    }

    @Override
    public void removeAllKey(int key) {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public void clear() {

    }

    @Override
    public void display() {

    }
    
}

我们先来实现打印链表和得到链表长度

@Override
public int size() {
    ListNode cur = this.head;
    int count = 0;
    while(cur != null){
        cur = cur.next;
        count++;
    }
    return count;
}
@Override
public void display() {
    ListNode cur = this.head;
    while(cur != null){
        System.out.print(cur.val + " ");
        cur = cur.next;
    }
    System.out.println();
}

接下来实现头插法

在这里插入图片描述

@Override
public void addFirst(int data) {
    ListNode newNode = new ListNode(data);
    if(this.head == null){
        head = last = newNode;
        return;
    }
    head.prev = newNode;
    newNode.next = head;
    head = newNode;
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addFirst(56);
        list.addFirst(45);
        list.addFirst(34);
        list.addFirst(23);
        list.addFirst(12);
        list.display();
        list.addFirst(33);
        list.display();
        System.out.println(list.size());
    }
    //结果为：
    //12 23 34 45 56 
    //33 12 23 34 45 56 
    //6
}

实现尾插法
在这里插入图片描述

@Override
public void addLast(int data) {
    ListNode newNode = new ListNode(data);
    if(head == null){
        head = last = newNode;
        return;
    }
    last.next = newNode;
    newNode.prev = last;;
    last = newNode;
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
    }
    //结果为：
    //12 23 34 45 56
}

实现任意位置插入,第一个数据节点为0号下标
在这里插入图片描述

private ListNode findIndex(int index){
    ListNode cur = this.head;
    while(index != 0){
        cur = cur.next;
        index--;
    }
    return cur;
}
@Override
public void addIndex(int index, int data) {
    int len = size();
    if(index < 0 || index > len - 1){
        return;
    }
    if(index == 0){
        addFirst(data);
        return;
    }
    if(index == len - 1){
        addLast(data);
        return;
    }
    ListNode cur = findIndex(index);
    ListNode newNode = new ListNode(data);
    newNode.next = cur;
    cur.prev.next = newNode;
    newNode.prev = cur.prev;
    cur.prev = newNode;
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
        list.addIndex(2,33);
        list.display();
        list.addIndex(0,33);
        list.display();
        list.addIndex(6,33);
        list.display();
        list.addIndex(8,33);
        list.display();
    }
    //结果为：
    //12 23 34 45 56
    //12 23 33 34 45 56
    //33 12 23 33 34 45 56
    //33 12 23 33 34 45 56 33
    //33 12 23 33 34 45 56 33
}

实现删除第一次出现关键字为key的节点
在这里插入图片描述

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

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
        list.remove(12);
        list.display();
        list.remove(56);
        list.display();
        list.remove(34);
        list.display();
    }
    //结果为：
    //12 23 34 45 56
    //23 34 45 56
    //23 34 45
    //23 45
}

删除所有值为key的节点，我们只需要在删除第一次出现关键字为key的节点的代码上将return删除掉，让其循环到链表结尾

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

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addLast(23);
        list.addLast(33);
        list.addLast(34);
        list.addLast(23);
        list.addLast(23);
        list.display();
        list.removeAllKey(23);
        list.display();
    }
    //结果为：
    //23 33 34 23 23
    //33 34
}

实现查找是否包含关键字key是否在双向链表当中，我们只需要遍历链表，找到返回true，没找到返回false

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

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
        System.out.println(list.contains(34));
        System.out.println(list.contains(100));
    }
    //结果为：
    //12 23 34 45 56
    //true
    //false
}

接下来实现clear，我们可以直接暴力的将head和last置为null
但是最后是将每个结点的prev和last都置为null，我们需要一个curN保留下一个结点，最后还需要将head和last置为null

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

public class Test {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
        list.clear();
        list.display();
    }
    //结果为：
    //12 23 34 45 56
    //
}

LinkedList的使用

  1. LinkedList的构造
方法解释
LinkedList ()无参构造
LinkedList (Collection<? extends E> c)利用其他集合容器中元素构造List
import java.util.ArrayList;
import java.util.LinkedList;
public class Test {
    public static void main(String[] args) {
        //构造一个空的LinkedList
        LinkedList<Integer> list1 = new LinkedList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        System.out.println(list1);

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(11);
        list2.add(22);
        list2.add(33);
        list2.add(44);
        list2.add(55);
        //使用ArrayList构造LinkedList
        LinkedList<Integer> list3 = new LinkedList<>(list2);
        System.out.println(list3);

    }
    //结果为：
    //[1, 2, 3, 4, 5]
    //[11, 22, 33, 44, 55]
}
  1. LinkedList的其他常用方法介绍
方法解释
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
import java.util.LinkedList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list1 = new LinkedList<>();
        list1.add(1);   //add(elem)表示尾插
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        System.out.println(list1.size());   //5
        System.out.println(list1);      //[1, 2, 3, 4, 5]

        //在起始位置插入0
        list1.add(0,0);    //add(index,elem);在index位置插入元素elem
        System.out.println(list1);      //[0, 1, 2, 3, 4, 5]

        list1.remove();     //remove();删除第一个元素，内部调用的是removeFirst()
        System.out.println(list1);  //[1, 2, 3, 4, 5]
        list1.removeFirst();    //removeFirst();删除第一个元素
        System.out.println(list1);  //[2, 3, 4, 5]
        list1.removeLast();     //removeLast();删除最后一个元素
        System.out.println(list1);  //[2, 3, 4]
        list1.remove(1);    //remove(index);删除index位置的元素
        System.out.println(list1);  //[2, 4]

        //contains(elem):检测elem元素是否存在，如果存在返回true，否则返回false
        if(!list1.contains(1)){
            list1.add(0,1);
        }
        System.out.println(list1);  //[1, 2, 4]
        list1.addLast(1);
        System.out.println(list1);  //[1, 2, 4, 1]
        System.out.println(list1.indexOf(1));   //indexOf(elem);从前往后找第一个elem的位置 0
        System.out.println(list1.lastIndexOf(1));   //lastIndexOf(elem);从后往前找第一个elem的位置 3
        int elem = list1.get(0);    //get(index);获取指定位置元素
        System.out.println(elem);   // 1
        list1.set(0,100);   //set(index,elem);将index位置的元素设置为elem
        System.out.println(list1);  //[100, 2, 4, 1]

        //subList(from,to):用list1中[from,to)之间的元素构造一个新的LinkedList返回
        List<Integer> copy = list1.subList(0,3);
        System.out.println(list1);  //[100, 2, 4, 1]
        System.out.println(copy);   //[100, 2, 4]
        list1.clear();  //将list1中元素清空
        System.out.println(list1.size());   //0
    }
}
  1. LinkedList的遍历
public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list);

        System.out.println("======for=====");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();

        System.out.println("======for each=====");
        for(int x : list){
            System.out.print(x + " ");
        }
        System.out.println();

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

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

        System.out.println("======ListIterator拓展=====");
        ListIterator<Integer> lit2 = list.listIterator(list.size());
        while(lit.hasPrevious()){
            System.out.print(lit.previous() + " ");
        }
    }
    //结果为：
    //[1, 2, 3, 4, 5]
    //======for=====
    //1 2 3 4 5
    //======for each=====
    //1 2 3 4 5
    //======Iterator=====
    //1 2 3 4 5 
    //======ListIterator=====
    //1 2 3 4 5
    //======ListIterator拓展=====
    //5 4 3 2 1
}

ArrayList和LinkedList的区别

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

本篇文章到此，谢谢阅读，希望对您有帮助。

running up that hill
关注
专栏目录
java linkedlist用法_Java linkedList详细介绍及使用示例
weixin_30456719的博客
02-12 1442
①LinkedList简单介绍是一个继承于AbstractSequentialList的双向链表。它可以被当成堆栈、队列或双端队列进行操作。实现了List接口，能对它进行队列操作。实现了Deque接口，能当作双端队列使用。实现了Cloneable接口，覆盖了clone(),能克隆。实现了java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。是非同...
Java LinkedList
12-16
Java LinkedList 是Java集合框架中的一种数据结构，它属于线性表的一种，但不同于数组，它不会按照线性顺序存储数据。LinkedList 使用链式结构，每个节点包含两部分：当前节点的值和一个指向下一个节点的引用。对于...
Java LinkedList基本用法
热门推荐
Dream It Possible
12-01 18万+
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用. LinkedList的构造函数如下 1. public LinkedList(): ——生成空的链表 2. public LinkedList(Collection col): 复制构造函数 1、获取链表的第一个和最后一个元素 [java]view plaincopy
java Linkedlist
Claroja
04-04 281
Linkedlist
java linkedlist排序_Java LinkedList排序
weixin_42588877的博客
02-13 2004
首页>基础教程>集合框架>LinkedList类Java LinkedList排序LinkedList通过Collections.sort进行排序，代码如下：降序public class Person1 implements Comparable < Person1 > {private Float height;private String name;P...
java linkedlist poll_Java LinkedList poll()方法
weixin_39621695的博客
02-13 1439
Java LinkedList poll()方法java.util.LinkedList.poll() 检索并删除LinkedList的第一个元素。1 语法public E poll()2 参数无3 返回值返回LinkedList的第一个元素；如果LinkedList为空，则返回null4 示例package com.yiidian;/*** 一点教程网： http://www.yiidian.c...
peek java linkedlist_Java LinkedList peek()方法
weixin_42386361的博客
02-19 1472
Java LinkedList peek()方法java.util.LinkedList.peek()检索LinkedList的头部元素(第一个元素)。1 语法public E peek()2 参数无3 返回值返回LinkedList的头部元素；如果LinkedList为空，则返回null。4 示例package com.yiidian;/*** 一点教程网： http://www.yiidia...
java linkedlist 删除_Java LinkedList remove()方法
weixin_42668301的博客
02-12 706
Java LinkedList remove()方法java.util.LinkedList.remove(Object o)方法从LinkedList中删除第一次出现的指定元素。如果LinkedList不包含该元素，则它保持不变。1 语法public boolean remove(Object o)2 参数o：要从LinkedList中删除的元素(如果存在)3 返回值如果此列表包含指定的元素，...
java linkedlist 删除_Java LinkedList.remove() 删除数据
weixin_33417904的博客
02-12 4471
首页>基础教程>集合框架>LinkedList类Java LinkedList.remove() 删除数据方法remove()：获取并移除此列表的头(第一个元素)。remove(int index)：移除此列表中指定位置处的元素。remove(Objec o)：从此列表中移除首次出现的指定元素(如果存在)。removeFirst()：移除并返回此列表的第一个元素。re...
java linkedlist pop_Java中LinkedList那点事
weixin_30696755的博客
02-13 722
1.简介LinkedList是 List和 Deque接口的双向链表实现。它实现所有可选的列表操作并允许所有元素(包括 null)。2.特点您可以在下面找到LinkedList最重要的属性：索引到列表中的操作将从开头或结尾遍历列表，以较接近指定索引为准它不同步它的Iterator和ListIterator迭代器是快速-失败的(这意味着在迭代器创建之后，如果修改了列表，将抛出一个Concurrent...
java LinkedList的实例详解
08-29
"java LinkedList实例详解" Java LinkedList是一种基于链表的数据结构，在Java语言中广泛应用于实现队列、栈、双端队列等数据结构。下面将对Java LinkedList的实例进行详细的解释。 1. LinkedList类结构 Java ...
Java LinkedList教程
08-23
Java LinkedList 教程 Java LinkedList 是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。链表可分为单向链表和双向链表。一个单向链表包含两个...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1209
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 356
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 519
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 321
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1347
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
Spring Boot 整合 Minio
cmh1008611的博客
10-09 593
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
java linkedlist
09-13
Java的LinkedList是一种常用的数据容器，类似于ArrayList。LinkedList与ArrayList相比，在增加和删除元素时效率更高，而在查找和修改元素时效率较低。可以使用for循环和get方法来遍历LinkedList中的元素，也可以使用foreach循环来遍历。对于添加元素，LinkedList提供了add、addFirst和addLast等方法；对于删除元素，LinkedList提供了removeFirst和removeLast等方法；对于查找元素，LinkedList提供了getFirst和getLast等方法。关于LinkedList和ArrayList的选择取决于具体的需求和操作频率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值