Day 09 List子接口LinkedList

已于 2023-01-14 09:43:27 修改
阅读量170 收藏
点赞数 1
文章标签： list 链表 数据结构 java
于 2023-01-14 00:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49084227/article/details/128681479
版权

List子接口LinkedList

LinkedList引入

ArrayList ： 底层是数组，通过下标就能查询，它的查询比较快，但是删除比较慢 LinkedList：底层是双向链表，要一个一个的遍历，没有下标，所以数据比较多的时候查询比较 慢，但是它比较适合添加和删除操作。

  • 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

  • LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末 元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。

LinkeList前置基础知识

单项链表

element：用来存放元素

next：用来指向下一个节点 通过每个节点的指针指向下一个节点从而连接起来的结构，最后一个节点的next指向null

在这里插入图片描述

单向循环链表

在单向链表的最后一个节点的next会指向头节点，而不是指向null，这样存成一个环。

在这里插入图片描述

双向链表

element：用来存放元素

pre：用来指向上一个节点

next：用来指向下一个节点 双向链表包含两个指针，pre指向前一个节点， next 指向后一个指针，但是第一个节点head（头节点） 的pre指向null，最后一个节点的tail指向null。

在这里插入图片描述

双向循环链表

lement、pre、next 跟前面的一样

第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。
在这里插入图片描述

LinkedList常用方法

方法名说明
void addFirst(Object o)在链表的头部添加元素
void addLast(Object o)在链表的尾部添加元素
Object getFirst()获取链表中的第一个元素
Object getLast()获取链表中的最后一个元素
Object removeFirst删除中的第一个元素
Object removeLast()删除链表中的最后一个元素
public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("aaa");//添加到数组
        linkedList.add("bbb");
        linkedList.add("ccc");
        linkedList.add("ddd");
        linkedList.add("eee");
        System.out.println(linkedList);//打印出添加后的数组
        //linkedList.clear();
        linkedList.offerFirst("eee");//在首位添加元素
        System.out.println(linkedList);
        linkedList.addFirst("qqq");//继续在首位添加元素
        System.out.println(linkedList);
        linkedList.removeFirst();//移除首位元素
        System.out.println(linkedList);
        linkedList.pollFirst();
        //方法检索并删除此列表的第一个元素，如果此列表为空，则返回 null
        System.out.println(linkedList);
    }

链表的原理及实现

什么是链表？

链表是由n个子节点组合起来的一种线性数据结构 链表的特性：

  • 链表是以节点（Node）的方式来存储，所以又叫链式存储
  • 节点可以连续存储，也可以不连续存储
  • 节点的逻辑顺序与物理顺序可以不一致
  • 链表可以扩充

单链表

两个部分：

  • data域：数据域，用来存储元素数据
  • next域：用于指向下一节点

在这里插入图片描述

单链表的操作

单链表的所有操作都是从head开始，head本身不存储元素，其next指向第一个节点，然后顺着next链表 进行一步步操作。其尾部节点的next指向为空，这也是判断尾部节点的依据。

插入节点

向单链表中插入一个新节点，可以通过调整两次next指向来完成。

x为新节点，将其next指向A2，再将A1的next指向X即可。

如果是从尾节点插入，直接将尾节点的next指向新节点就可以了。

在这里插入图片描述

删除操作

从单链表中删除一节点，通过修改next指向来实现。

将A1的next 指向为A2，这样就能删除 X， X的内存空间会自动被垃圾回收。

在这里插入图片描述

代码实现
public class Node {
    public String data;
    public Node next;
    public Node(String data) {
        this.data = data;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
    @Override
    public String toString() {
        return "Node{" +
                "data='" + data + '\'' +
                ", next=" + next +
                '}';
    }
}

 private Node head = new Node(null);//得有head节点，是单链表的开始
 


//添加节点
public void add(Node node){
        Node temp = head;//temp存储头节点
        while (true) {//判断node是否为空
            if (temp.next == null){
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
    }

在这里插入图片描述

singleLinkedList.add(aaa);
singleLinkedList.add(bbb);

在这里插入图片描述

在这里插入图片描述

    //指定节点插入元素
    public void addOfOrder(Node node, String name) {
        Node temp = head;
        while (true) {
            if (temp.next == null){
                temp.next = node;
                break;
            }else if (name == temp.getData()) {
                node.next = temp.next;
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
    }

singleLinkedList.addOfOrder(eee,"bbb");

在这里插入图片描述

//查找获取数据
public Node get(String key) {
    if (head.next == null) {
        return null;
    }
    Node temp = head.next;
    while (temp != null){
        if (temp.data == key) {
            return temp;
        }
        temp = temp.next;
    }
    return null;
}

//移除数据
   public void remove(Node node) {
        Node temp = head.next;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.data == node.data) {
                temp.next = temp.next.next;//断开连接
                break;
            }
            temp = temp.next;
        }
    }

在这里插入图片描述

//修改叫这个node节点的名字name
public void update(Node node, String name) {
        Node temp = head.next;//这句话一般都不变，都要用
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.data == name) {
                temp.data = node.data;
                break;
            }
            temp = temp.next;
        }
    }

//测试
public static void main(String[] args) {
        Node aaa = new Node("aaa");
        Node bbb = new Node("bbb");
        Node ccc = new Node("ccc");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(aaa);
        singleLinkedList.add(bbb);
        singleLinkedList.add(ccc);
        singleLinkedList.print();
        System.out.println("=====================");
        Node eee = new Node("eee");
        singleLinkedList.addOfOrder(eee,"bbb");
        singleLinkedList.print();
        System.out.println("=====================");
        System.out.println(singleLinkedList.get("eee"));
        System.out.println(singleLinkedList.get("qqq"));
        System.out.println("=====================");
        singleLinkedList.remove(ccc);
        singleLinkedList.print();
        System.out.println("=====================");
        singleLinkedList.update(new Node("www"), "eee");
        singleLinkedList.print();

双向链表

双向链表其节点由三部分构成：

  • prev域：用于指向上一节点

  • data域：数据域，用来存储元素数据

  • next域：用于指向下一节点

在这里插入图片描述

双向链表的操作

双向链表的操作可以从两端开始，从第一个节点通过next指向可以一步步操作到尾部，从最后一个节点 通过prev指向可以一步步操作到头部。

插入节点

像双向链表中插入一个节点，需要调整两次 pre指向 和 两次 next 指向。

X为新节点，将A1的next指向X，将x的next指向A2，将A2的pre指向X，将X 的pre指向A1。

在这里插入图片描述

删除节点

从双向链表中删除一个节点，需要调整一次 pre 指向 和 一次 next 指向就可以了。

将A1的 next指向 A2， 将A2的pre 指向 A1。

在这里插入图片描述

代码实现
public class DoubleNode {
    public final int key;
    public String value;
    public DoubleNode pre;
    public DoubleNode next;
    public DoubleNode(int key, String value) {
        this.key = key;
        this.value = value;
    }
    @Override
    public String toString() {
        return "DoubleNode{" +
                "key=" + key +
                ", value='" + value + '\'' +
                '}';
    }
}


public class DoubleLinkedList {
    public DoubleNode first = null; //双链表的头部，也就是第一个节点
    public DoubleNode last = null; //双链表的尾部，也就是最后一个节点

    /**
     * @Description //TODO 从尾部添加节点
     */
    public DoubleLinkedList addToTail(DoubleNode node) {
        if (last == null) {
            first = node;
        } else {
            last.next = node;
            node.pre = last;
        }
        last = node;
        return this;
    }

    /**
     * @Description //TODO 从头部开始添加
     */
    public DoubleLinkedList addToHead(DoubleNode node) {
        if (first == null) {
            last = node;
        } else {
            node.next = first;
            first.pre = node;
        }
        first = node;
        return this;
    }

    /**
     * @Description //TODO 按照key key顺序添加
     */
    public DoubleLinkedList addOfOrder(DoubleNode node) {
        if (first == null) {
            first = node;
            last = node;
            return this;
        }
//node 比头节点小，将 node 设为头肩
        if (first.key > node.key) {
            first.pre = node;
            node.next = first;
            first = node;
            return this;
        }
//node 比尾节点大，将node变为 尾节点
        if (node.key > last.key) {
            last.next = node;
            node.pre = last;
            last = node;
            return this;
        }
        DoubleNode temp = first.next;
        while (true) {
            if (temp.key > node.key) {
                node.next = temp;
                node.pre = temp.pre;
                temp.pre.next = node;
                temp.pre = node;
                break;
            }
            temp = temp.next;
        }
        return this;
    }

    /**
     * @Description //TODO 获取节点
     */
    public DoubleNode get(int key) {
        if (first == null) {
            return null;
        }
        DoubleNode temp = first;
        while (temp != null) {
            if (temp.key == key) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }

    /**
     * @Description //TODO 删除
     */
    public DoubleLinkedList remove(DoubleNode node) {
        if (first == null) {
            return this;
        }
//如果删除的是头节点
        if (first == node) {
            first.next.pre = null;
            first = first.next;
            return this;
        }
//如果删除的是为节点
        if (last == node) {
            last.pre.next = null;
            last = last.pre;
            return this;
        }
        DoubleNode temp = first.next;
        while (temp != null) {
            if (temp.key == node.key) {
                temp.pre.next = temp.next;
                temp.next.pre = temp.pre;
                break;
            }
            temp = temp.next;
        }
        return this;
    }

    /**
     * @Description //TODO
     */
    public DoubleLinkedList update(DoubleNode node) {
        if (first == null) {
            return this;
        }
        DoubleNode temp = first;
        while (temp != null) {
            if (temp.key == node.key) {
                temp.value = node.value;
                break;
            }
            temp = temp.next;
        }
        return this;
    }

    public void print() {
        if (first == null) {
            return;
        }
        DoubleNode temp = first;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    public static void main(String[] args) {
        DoubleNode aaa = new DoubleNode(1, "aaa");
        DoubleNode bbb = new DoubleNode(2, "bbb");
        DoubleNode ccc = new DoubleNode(6, "ccc");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addToTail(aaa);
        doubleLinkedList.addToTail(bbb);
        doubleLinkedList.addToTail(ccc);
        doubleLinkedList.print();
        System.out.println("===================");
        DoubleNode ddd = new DoubleNode(4, "ddd");
        doubleLinkedList.addToHead(ddd);
        doubleLinkedList.print();
        System.out.println("===================");
        DoubleNode eee = new DoubleNode(3, "eee");
        doubleLinkedList.addOfOrder(eee);
        doubleLinkedList.print();
        System.out.println("===================");
        System.out.println(doubleLinkedList.get(7));
        System.out.println("===================");
        doubleLinkedList.remove(new DoubleNode(1, "aaa"));
        doubleLinkedList.print();
        System.out.println("===================");
        doubleLinkedList.update(new DoubleNode(2, "herb"));
        doubleLinkedList.print();
    }
}

源码分析

LinkedList特性

  1. LinkedList 集合底层实现的数据结构为双向链表
  2. LinkedList 集合中元素允许为 null
  3. LinkedList 允许存入重复的数据
  4. LinkedList 中元素存放顺序为存入顺序。
  5. LinkedList 是非线程安全的
  6. 如果在频繁的插入，或者删除数据时，就用linkedList性能会更好。

继承结果及层次关系

在这里插入图片描述

类的属性

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
//LinkedList 中的节点个数
transient int size = 0;
//LinkedList 链表的头节点
transient Node<E> first;
//LinkedList 链表的 尾节点
transient Node<E> last;
}

构造方法

  1. 空构造器
//空构造器生成一个空链表 ==> frist = last = null
public LinkedList() {
}
  1. 有参构造器
// 将集合 c 中的 各个元素构建成 LinkedList 链表
public LinkedList(Collection<? extends E> c) {
//调用无参构造器
this();
//添加集合中的所有元素
addAll(c);
}

内部类（Node）

private static class Node<E> {
     E item; //节点的值
     Node<E> next; //用于指向下一节点（后继）
     Node<E> prev;//用于指向上一节点（前驱）
     //构造函数，赋值 前驱后继
     Node(Node<E> prev, E element, Node<E> next) {
     this.item = element;
     this.next = next;
     this.prev = prev;
    }
}

说明：内部类 Node 就是实际的节点，用于存放实际元素的地方

add()

public boolean add(E e) {
//将元素添加到链表的末尾
linkLast(e);
return true;
}

说明：add函数用于向LinkedList中添加一个元素，并且添加到链表尾部。具体添加到尾部的逻辑是由 linkLast函数完成的。

    void linkLast(E e) {
        //临时节点 l（L的小写）保存last,也就是 l 指向最后一个节点
        final Node<E> l = last;
        //将e（值）封装为节点，并且e.perv指向了最后一个节点
        final Node<E> newNode = new Node<>(l, e, null);
        //newNode 成为最后一个节点
        last = newNode;
        // 判断之前的链表是否为空，如果为空，那么 newNode 就成为了头节点
        if (l == null)
            first = newNode;
        else //否则将之前的尾节点 的 next 指向 newNode（新节点）
            l.next = newNode;
        size++;///添加了节点，size要自增
        modCount++;
    }

的末尾
linkLast(e);
return true;
}


说明：add函数用于向LinkedList中添加一个元素，并且添加到链表尾部。具体添加到尾部的逻辑是由 linkLast函数完成的。


void linkLast(E e) {
    //临时节点 l（L的小写）保存last,也就是 l 指向最后一个节点
    final Node<E> l = last;
    //将e（值）封装为节点，并且e.perv指向了最后一个节点
    final Node<E> newNode = new Node<>(l, e, null);
    //newNode 成为最后一个节点
    last = newNode;
    // 判断之前的链表是否为空，如果为空，那么 newNode 就成为了头节点
    if (l == null)
        first = newNode;
    else //否则将之前的尾节点 的 next 指向 newNode（新节点）
        l.next = newNode;
    size++;///添加了节点，size要自增
    modCount++;
}

在这里插入图片描述

为生发时刻准备着
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java基础-day14-Collection接口·List父类接口·ArrayList子类·LinkedList 链表 ·set接口·Map接口·HashMap
weixin_58678891的博客
06-22 377
Collection接口·List父类接口·ArrayList子类可实现类·LinkedList 链表 子类可实现类·set接口·Map接口·HashMap 可实现子类
java Queue中 remove/poll, add/offer, element/peek区别
热门推荐
JackyLau的专栏
01-06 7万+
这里简单对其重复的方法做点简单的区分。 offer，add区别： 一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。 这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。    poll，remove区别： remove() 和 poll() 方法都是
Java LinkedList对象的element（）方法和示例
cumt30111的博客
07-04 744
LinkedList对象element()方法 (LinkedList Object element() method) This method is available in package java.util.LinkedList.element(). 软件包java.util.LinkedList.element()中提供了此方法。 This method is used to retri...
Java集合---LinkedList源码解析
weixin_34166847的博客
09-01 878
  一、源码解析1、 LinkedList类定义2、LinkedList数据结构原理3、私有属性4、构造方法5、元素添加add()及原理6、删除数据remove()7、数据获取get()8、数据复制clone()与toArray()9、遍历数据：Iterator()二、ListItr     一、源码解析     1、 LinkedList类定义。   public class ...
Java中listElem_Java LinkedList element()方法
weixin_39576066的博客
02-25 289
Java LinkedList element()方法java.util.LinkedList.element()方法用于检索LinkedList的第一个元素。1 语法public E element()2 参数无3 返回值返回LinkedList的第一个元素。4 示例package com.yiidian;/*** 一点教程网： http://www.yiidian.com*//*** jav...
Day14_list接口
qq_36972345的博客
07-23 75
一、list接口 1.1List简介 List接口是Collection的子接口，实现List接口的容器类中的元素是有顺序的，而且可以重复。 List容器中的元素都对应一个整数型的序号记录其在容器中的位置，可以根据此序号存取元素。 主要实现类有 ArrayList 和 LinkedList。 1.2List接口中的方法 相对Collection接口扩展的方法 Object get(int index); 通过索引获取元素 Object set(int index,Object ele
014泛型、接口、LinkedList、ArrayList
m0_55284524的博客
04-04 114
1.泛型 1.1概念 public class LinkedList extends Abstract Sequential implements List public interface Deque extends Queue { } public interface Queue extends Collection { } public interface Collection extends Iterable { } 上面的代码中出现的<?>是泛型，常用来和集
day15 API04-1集合--泛型、Collection接口、List接口、ArrayList、LinkedList
weixin_58580280的博客
06-18 266
1.泛型 为什么引入泛型？ 1）泛型是为了模拟数组的元素；类型检查 2）泛型通常与集合一起使用 3）泛型的格式：<type>
list接口和set集合
Cocobuhui的博客
10-27 184
list接口和set集合
【Java】day15--Collection接口、List接口、ArrayList类、LinkedList类、HashSet类部分知识点总结
Greenary的博客
03-08 172
（一）集合实现用户注册登录 //用户类 class User{ private String userName;//封装，保证数据安全，防止被更改 private String password; //构造函数 public User(String userName, String password) { super(); this.userName = userName; ...
java list存储数据结构_List接口、集合存储数据结构、arraylist、linkedlist、vector集合、set接口、hashset集合、...
weixin_35399893的博客
02-24 265
amList接口特点：①：有序集合(怎么存怎么取) ②：有下标(每个元素插入位置精确控制) ③：允许重复元素，equals方法比较是否重复元素List接口的常用子类有：ArrayList集合、Linkedlist集合常用方法除了 add(E e)和 remove，其他都是list接口独有 带下标list主要就是带下标的方法packagecom.oracle.demo01;importjava....
Day8_8 Java学习之List集合类
weixin_43717536的博客
08-08 2532
解析：1.List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。2.List 集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。3.List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。4.List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类。5.List集合的长度可变，且其中的数据类型只能为引用类型。............
Java——踩坑Arrays.asList()
Wanankl的博客
09-06 207
查看源码可以看到，asList返回到ArrayList是一个内部类，继承了AbstractList，再查看源码，并没有是哪set,add,remove方法。查看源码可以看到，接收入参为泛型，而基本类型并没有集成Object。asList之后new一个List给他。进行装箱或者直接使用包装类型。new一个新的List。报了不支持的操作异常。
【鸿蒙HarmonyOS NEXT】调用后台接口及List组件渲染
最新发布
若兰幽竹
09-06 647
调用后台接口，需要引入http模块或者其他诸如Ajax、axios等网络请求模块；如果是需要在页面被创建的时候调用后台接口，则需要在aboutToAppear()中进行调用，如需要在页面显示时需要调用后台接口加载数据，则可以在onPageShow()函数中进行调用。根据实际业务结合组件的生命周期进行合适的调用；如使用JSON.parse报错Structural typing is not supported (arkts-no-structural-typing)，其原因是引入。
集合框架，List常用API，栈和队列初识
Wuweinan_190cm的博客
09-03 531
两个重点——ArrayList和HashSet.
关于List接口及ArrayList子接口、LinkedList子接口中常用方法的练习
05-19
好的，下面给你提供一些关于List接口及其子接口ArrayList和LinkedList中常用方法的练习题。 1. 创建一个ArrayList，向其中添加5个元素，然后使用for循环遍历输出每个元素。 2. 创建一个LinkedList，向其中添加10个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值