容器-------LinkedList（链表）

最新推荐文章于 2025-04-22 23:18:11 发布
原创 最新推荐文章于 2025-04-22 23:18:11 发布 · 131 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文通过自定义一个链表，详细介绍了链表的基础结构，包括get方法的实现、remove方法的添加以及如何插入节点。同时，还探讨了使用泛型对链表进行封装，以增强其灵活性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

自定义一个链表，体会底层原理

基础结构
public class JtLinkedList01 {
    private Node first;
    private Node last;
    private  int size;
    //[]
    //["a","b","c"]
    public void add(Object object){
        Node node = new Node(object);
        if (first==null){
//            node.previous =null;
//            node.next = null;
            first = node;
            last = node;
        }else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
    }

@Override
public String toString() {
    StringBuilder stringBuilder = new StringBuilder("[");
    Node temp = first;
    while (temp!=null){
        stringBuilder.append(temp.element+",");
        temp = temp.next;
    }
    stringBuilder.setCharAt(stringBuilder.length()-1,']');
    return stringBuilder.toString();
}

public static void main(String[] args) {
    JtLinkedList01 jtLinkedList01 = new JtLinkedList01();
    jtLinkedList01.add("a");
    jtLinkedList01.add("b");
    jtLinkedList01.add("c");
    jtLinkedList01.add("c");
    jtLinkedList01.add("c");
    jtLinkedList01.add("c");
    System.out.println(jtLinkedList01);
  }
}
增加get方法
public class JtLinkedList02 {
    private Node first;
    private Node last;
    private  int size;
    public Object get(int index){
        if (index <0||index>size-1){
            throw new RuntimeException("索引数字不合法"+index);
        }
        Node temp = null;
        if (index<=(size>>1)){ //size>>1相当于除以2
            temp = first;
            for (int i = 0;i<index;i++){
                temp = temp.next;
            }
        }else {
            temp = last;
            for (int i  = size-1;i >index;i-- ){
                temp = temp.previous;
            }
        }
        return temp.element;
    }
    //[]
    //["a","b","c"]
    public void add(Object object){
        Node node = new Node(object);
        if (first==null){
//            node.previous =null;
//            node.next = null;
            first = node;
            last = node;
        }else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[");
        Node temp = first;
        while (temp!=null){
            stringBuilder.append(temp.element+",");
            temp = temp.next;
        }
        stringBuilder.setCharAt(stringBuilder.length()-1,']');
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        JtLinkedList02 jtLinkedList02 = new JtLinkedList02();
        jtLinkedList02.add("a");
        jtLinkedList02.add("b");
        jtLinkedList02.add("c");
        jtLinkedList02.add("d");
        jtLinkedList02.add("e");
        jtLinkedList02.add("f");
        System.out.println(jtLinkedList02);
        System.out.println(jtLinkedList02.get(1));
    }
}
增加remove方法
public class JtLinkedList03 {
    private Node first;
    private Node last;
    private  int size;
    public void remove(int index) {
        Node temp = getNode(index);
        if (temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            if (up != null) {
                up.next = down;
            }
            if (down != null) {
                down.previous = up;
            }
            //被删除的元素是第一个
            if (index==0){
                first = down;
            }
            //被删除的元素是最后一个
            if (index==size-1){
                last = up;
            }
            size--;
        }
    }
    public Object get(int index){
        if (index <0||index>size-1){
            throw new RuntimeException("索引数字不合法"+index);
        }
        Node temp = getNode(index);
        return temp!=null?temp.element:null;
    }
    public Node getNode(int index){
        Node temp = null;
        if (index<=(size>>1)){ //size>>1相当于除以2
            temp = first;
            for (int i = 0;i<index;i++){
                temp = temp.next;
            }
        }else {
            temp = last;
            for (int i  = size-1;i >index;i-- ){
                temp = temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c"]
    public void add(Object object){
        Node node = new Node(object);
        if (first==null){
//            node.previous =null;
//            node.next = null;
            first = node;
            last = node;
        }else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[");
        Node temp = first;
        while (temp!=null){
            stringBuilder.append(temp.element+",");
            temp = temp.next;
        }
        stringBuilder.setCharAt(stringBuilder.length()-1,']');
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        JtLinkedList03 jtLinkedList03 = new JtLinkedList03();
        jtLinkedList03.add("a");
        jtLinkedList03.add("b");
        jtLinkedList03.add("c");
        jtLinkedList03.add("d");
        jtLinkedList03.add("e");
        jtLinkedList03.add("f");
        System.out.println(jtLinkedList03);
        jtLinkedList03.remove(3);
        System.out.println(jtLinkedList03);
        System.out.println(jtLinkedList03.get(1));
        jtLinkedList03.remove(0);
        System.out.println(jtLinkedList03);
        jtLinkedList03.remove(3);
        System.out.println(jtLinkedList03);
    }
}
插入节点
public class JtLinkedList04 {
    private Node first;
    private Node last;
    private int size;

    public void add(int index, Object object) {
        Node temp = getNode(index);
        Node newNode = new Node(object);
        Node up = temp.previous;
        if (temp != null) {
            if (0<index&&index<size-1) {
                up.next = newNode;
                newNode.previous = up;
                newNode.next = temp;
                temp.previous = newNode;
            }
            if (index == 0) {
                first = newNode;
                newNode.previous = null;
                newNode.next = temp;
                temp.previous = newNode;
            }
            if (index == size-1){
                last = newNode;
                newNode.previous = temp.next;
                newNode.next = null;
                temp.next = newNode;
            }
            if (index<0||index>size){
                throw new RuntimeException("索引数字不合法"+index);
            }
            size++;
        }
    }

    public void remove(int index) {
        Node temp = getNode(index);
        if (temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            if (up != null) {
                up.next = down;
            }
            if (down != null) {
                down.previous = up;
            }
            //被删除的元素是第一个
            if (index == 0) {
                first = down;
            }
            //被删除的元素是最后一个
            if (index == size - 1) {
                last = up;
            }
            size--;
        }
    }

    public Object get(int index) {
        if (index < 0 || index > size - 1) {
            throw new RuntimeException("索引数字不合法" + index);
        }
        Node temp = getNode(index);
        return temp != null ? temp.element : null;
    }

    public Node getNode(int index) {
        Node temp = null;
        if (index <= (size >> 1)) { //size>>1相当于除以2
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c"]
    public void add(Object object) {
        Node node = new Node(object);
        if (first == null) {
//            node.previous =null;
//            node.next = null;
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[");
        Node temp = first;
        while (temp != null) {
            stringBuilder.append(temp.element + ",");
            temp = temp.next;
        }
        stringBuilder.setCharAt(stringBuilder.length() - 1, ']');
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        JtLinkedList04 jtLinkedList04 = new JtLinkedList04();
        jtLinkedList04.add("a");
        jtLinkedList04.add("b");
        jtLinkedList04.add("c");
        jtLinkedList04.add("d");
        jtLinkedList04.add("e");
        jtLinkedList04.add("f");
        System.out.println(jtLinkedList04);
        jtLinkedList04.remove(3);
        System.out.println(jtLinkedList04);
        System.out.println(jtLinkedList04.get(1));
        jtLinkedList04.remove(0);
        System.out.println(jtLinkedList04);
        jtLinkedList04.remove(3);
        System.out.println(jtLinkedList04);
        jtLinkedList04.add(0, false);
        System.out.println(jtLinkedList04);
        jtLinkedList04.add(0,false);
        System.out.println(jtLinkedList04);
        jtLinkedList04.add(4,4);
        System.out.println(jtLinkedList04);
        jtLinkedList04.add(5,5);
        System.out.println(jtLinkedList04);
    }
}
增加小的封装增加泛型
public class JtLinkedList05 <E>{
    private Node first;
    private Node last;
    private int size;

    public void add(int index, E element) {
        checkRange(index);
        Node temp = getNode(index);
        Node newNode = new Node(element);
        Node up = temp.previous;
        if (temp != null) {
            if (0 < index && index < size - 1) {
                up.next = newNode;
                newNode.previous = up;
                newNode.next = temp;
                temp.previous = newNode;
            }
            if (index == 0) {
                first = newNode;
                newNode.previous = null;
                newNode.next = temp;
                temp.previous = newNode;
            }
            if (index == size - 1) {
                last = newNode;
                newNode.previous = temp.next;
                newNode.next = null;
                temp.next = newNode;
            }
            size++;
        }
    }

    public void remove(int index) {
        checkRange(index);
        Node temp = getNode(index);
        if (temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            if (up != null) {
                up.next = down;
            }
            if (down != null) {
                down.previous = up;
            }
            //被删除的元素是第一个
            if (index == 0) {
                first = down;
            }
            //被删除的元素是最后一个
            if (index == size - 1) {
                last = up;
            }
            size--;
        }
    }

    public E get(int index) {
        checkRange(index);
        Node temp = getNode(index);
        return temp != null ? (E) temp.element : null;
    }

    private void checkRange(int index) {
        if (index < 0 || index > size - 1) {
            throw new RuntimeException("索引数字不合法" + index);
        }
    }

    private Node getNode(int index) {
        checkRange(index);
        Node temp = null;
        if (index <= (size >> 1)) { //size>>1相当于除以2
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c"]
    public void add(E element) {
        Node node = new Node(element);
        if (first == null) {
//            node.previous =null;
//            node.next = null;
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[");
        Node temp = first;
        while (temp != null) {
            stringBuilder.append(temp.element + ",");
            temp = temp.next;
        }
        stringBuilder.setCharAt(stringBuilder.length() - 1, ']');
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        JtLinkedList05<String> jtLinkedList05 = new JtLinkedList05<>();
        jtLinkedList05.add("a");
        jtLinkedList05.add("b");
        jtLinkedList05.add("c");
        jtLinkedList05.add("d");
        jtLinkedList05.add("e");
        jtLinkedList05.add("f");
        System.out.println(jtLinkedList05);
        jtLinkedList05.remove(3);
        System.out.println(jtLinkedList05);
        System.out.println(jtLinkedList05.get(1));
        jtLinkedList05.remove(0);
        System.out.println(jtLinkedList05);
        jtLinkedList05.remove(3);
        System.out.println(jtLinkedList05);
        jtLinkedList05.add(0, "false");
        System.out.println(jtLinkedList05);
        jtLinkedList05.add(0, "true");
        System.out.println(jtLinkedList05);
        jtLinkedList05.add(4, "4");
        System.out.println(jtLinkedList05);
        jtLinkedList05.add(5, "5");
        System.out.println(jtLinkedList05);
        System.out.println(jtLinkedList05.get(1));
    }
}
容器 - LinkedList源码
weixin_43191747的博客
04-11 244
LinkedList是一个实现了List接口和Deque接口的双端链表。LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性;LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法：Node类：LinkedList的私有内部类，用以表示一个链表节点。E item;//节点值//后继节点//前驱节点。
鸿蒙南向（OpenHarmony）线性容器-LinkedList
adaedwa187545的博客
11-29 981
LinkedList底层通过双向链表实现，双向链表的每个节点都包含对前一个元素和后一个元素的引用。当需要查询元素时，可以从头遍历，也可以从尾部遍历，插入、删除效率高，查询效率低。LinkedList允许元素为null。
数据结构*链表- LinkedList
2401_87791120的博客
04-22 1152
相较于ArrayList顺序表来说，链表是物理存储结构上非连续存储结构（也就是链表由一系列节点构成，每个节点包含数据和指向下一个节点的引用。链表的各个节点在内存里并非连续存储，而是。节点就相当于下图所示：value用来存储数据，next用来引用下一个节点。
Java-容器-LinkedList
2402_88479893的博客
11-05 344
int lastIndexOf (Object o) 返回最后一个匹配元素的索引，如果没有该元素，返回-1。LinkedList类相当于一个车厢节点，记录了上一个节点的地址和下一个节点的地址，中间这个节点也可以保存数据。LinkedList实现了List接口，所以LinkedList是具备List的存储特征的(有序，元素有重复)。特点：查询效率低，增删效率高，线程不安全。需要注意的是LinkedList也有索引，但不是指元素的索引，而是指链表中节点的位置。
List容器-LinkedList链表
weixin_33998125的博客
11-18 80
LinkedList--链表 特点: 　　删除,增加 用LinkedList性能高 层次查找不适合 　查询用ArrayList 数组下标查找 插入和删除慢缺点是要做移位操作 　　总结:LinkedList内部封装的是双向链表数据结构,每个节点是一个Node对象,Node对象封装的是你要添加的元素, 还有一个指向上一个Node对象的应用和指向下一个Node对象的引用, ...
数据结构-LinkedList和链表
2301_76928097的博客
01-20 2779
LinkedList是Java集合框架中的链表，LinkedList是基于双向链表实现的，由于链表中没有将元素存储在连续的空间内，元素存储在单独的节点中，然后通过引用将节点连接起来，因此在任意位置插入或者删除元素，不需要搬移元素，效率比较高。LinkedList中的节点结构：说明：1.LinkedList实现了List接口2.LinkedList的底层使用了双向链表3.LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问。
谈谈Java容器-LinkedList
技术进阶之路
06-05 303
之前的文章中，我们谈到了ArrayList的源码分析，在今天的文章中，我们来看一种和ArrayList非常相似的Java容器——LinkedList。 链表 谈到LinkedList，我们就不得不谈到它的底层数据结构——链表。 private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Nod
数据结构--链表
Lotus_zyz的博客
10-17 1064
链表也是线性表的一种，是一种物理存储结构上非连续存储的存储结构，其中数据元素的逻辑顺序通过链表中的引用链接次序实现。链表的结构非常多样，可以是单向的或多向带头或不带头的，循环或非循环的。
Java容器-LinkedList
ans31791的博客
11-19 108
LinkedList简介 　　LinkedList是基于双向链表实现的。链表是一种递归的数据结构，它或者为空(null)，或者指向一个节点(node)的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用，而双向链表的节点内含有两个指向另一条链表的引用。 用嵌套类定义节点 1 private class Node<E>{ 2 E item...
Java-数据结构-链表(LinkedList)-双向链表
爱是小小的癌的博客
01-09 1662
主要分享关于LinkedList的相关知识，希望能给你们带来帮助
JAVA-容器 LinkedList
卢大宝宝的博客
09-03 285
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修
Java-实用程序设计第章-容器类(共52张PPT).pptx
11-15
LinkedList基于双向链表，适合频繁的插入和删除操作，但随机访问效率较低。 2. **Map接口**：Map接口存储键值对，提供通过键查找值的能力。常见的Map实现类有HashMap、TreeMap和LinkedHashMap。HashMap使用哈希表...
Java-集合容器-1.集合框架、Set集.ppt
07-03
LinkedList是基于链表实现的，支持快速的插入和删除操作。ArrayList基于动态数组实现，读取速度快。 Map集的实现类有HashMap、Hashtable和TreeMap。HashMap基于哈希表实现，不保证元素的顺序。Hashtable是线程安全...
链表-使用C++语言实现面向对象的单链表.zip
03-13
链表是一种基础且重要的数据结构，它在计算机科学中被广泛应用于各种算法和程序设计中。与数组不同，链表的元素不是存储在...对于大型项目，还可以考虑使用STL中的`std::list`容器，它提供了更加完善的链表功能和优化。
samba-vfs-iouring-4.14.5-7.el8_5.tar.gz
08-18
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
rubygem-ffi-1.10.0-3.el8.tar.gz
08-18
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
COMSOL相场方法在裂缝多孔介质渗吸模拟中的应用及与水平集方法的比较 · 水平集方法
最新发布
08-18
内容概要：本文介绍了COMSOL相场方法在裂缝多孔介质渗吸模拟中的应用，详细探讨了相场方法在简单和复杂几何模型下两相流动的模拟过程。文中不仅展示了如何利用COMSOL软件创建几何模型、设定物理参数和边界条件，还比较了相场方法在守恒和非守恒条件下的计算结果差异，以及与水平集方法的对比。通过这些分析，揭示了相场方法在处理复杂边界条件和物理参数方面的优势。 适合人群：从事地质工程、石油勘探、环境科学等领域工作的研究人员和工程师。 使用场景及目标：适用于需要精确模拟和分析复杂地质条件下流体流动的研究项目，帮助提升工程设计的准确性和可靠性。 其他说明：文章强调了COMSOL相场方法在渗吸模拟中的优越性，同时也指出了水平集方法的特点，为选择合适的数值模拟方法提供了依据。
rubygem-mime-types-doc-3.2.2-1.el8.tar.gz
08-18
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
rubygem-puppet-resource_api-doc-1.8.13-1.el8.tar.gz
08-18
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
头歌数据结构与算法 - 链表
12-31
- 数据流处理过程中充当临时储存容器的角色以应对突发性的大量输入/输出请求等情形下的缓冲需求。 ### Python 中简单链表的实现 以下是使用Python编写的简易版单项链表类定义及其基本功能展示： ```python class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值