链表的底层实现（Java版）（单向，双向，循环）

于 2024-09-30 14:02:00 发布
阅读量690 收藏 5
点赞数 12
分类专栏： 数据结构与算法 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79840586/article/details/142654998
版权

目录

一.什么是链表？

链表的类型

链表的特点

使用场景：

二.单向链表的实现：

首先创建节点类以及对应的构造方法：

然后创造头结点（哨兵结点），方便找到固定的位置来对链表进行操作：

最后列出简单的对链表的增删改查操作： 

三.双向链表的实现：

首先创建节点类以及对应的构造方法：

 然后创建头尾哨兵，便于在两哨兵中间插入元素以及双向链表的操作：

随后创建这个双向链表的构造方法：

最后实现对双向链表的操作： 

四.双向循环链表的实现：

 首先创造哨兵结点以及其构造函数：

随后实现对双向循环链表的操作： 

一.什么是链表？

链表（Linked List） 是一种线性数据结构，其中元素称为节点（Node）。每个节点包含两个部分：

  1. 数据域（data）：存储节点的值。
  2. 指针域（next）：存储下一个节点的地址（或引用），指向链表中的下一个节点。

与数组不同，链表的元素在内存中不一定连续存储。链表的灵活性在于可以动态调整大小，因为元素的插入和删除操作不涉及移动其他元素。

链表的类型

  1. 单向链表（Singly Linked List）：每个节点只有一个指针指向下一个节点。
  2. 双向链表（Doubly Linked List）：每个节点有两个指针，一个指向前一个节点，一个指向下一个节点。
  3. 循环链表（Circular Linked List）：链表的最后一个节点指向第一个节点，形成一个闭环。

链表的特点

  • 动态大小：与数组不同，链表不需要在创建时指定大小。
  • 插入和删除效率高：特别是在中间或开头插入和删除操作，链表的效率要高于数组。
  • 随机访问效率低：由于链表节点不连续存储，无法像数组那样通过索引直接访问元素。

 

使用场景：

  • 频繁插入和删除：在需要频繁在中间插入和删除元素的场景，链表表现较好，因为插入和删除操作的时间复杂度为 O(1)，不需要像数组那样移动元素。
  • 动态大小：当不确定数据的大小时，链表比数组更适合，因为它可以根据需要动态调整大小。
  • 内存碎片化：链表不要求内存连续分配，适合在内存较为分散的场景。

二.单向链表的实现：

每个节点只有一个指针指向下一个节点。 

 

首先创建节点类以及对应的构造方法：

//结点类
//做成内部类，以此来对外隐藏
private static class Node {
    int value; // 值
    Node next; // 下一个结点指针

    public Node(int value, Node next) {
        this.value = value;
        this.next = next;
    }
}

然后创造头结点（哨兵结点），方便找到固定的位置来对链表进行操作：

private Node head = new Node(666,null);

最后列出简单的对链表的增删改查操作： 

package LinkListStudy;

import java.util.Iterator;
import java.util.function.Consumer;

public class SinglyLinkedListSentinel implements Iterable<Integer> {
    //头指针
//    private Node head = null;
    //哨兵结点
    private Node head = new Node(666,null);

    //迭代器遍历链表
    @Override
    public Iterator<Integer> iterator(){
        //匿名内部类 -> 带名字的内部类
        return new Iterator<>() {
            //头结点为哨兵结点，需要从下一个结点开始
            Node pointer = head.next;

            @Override
            public boolean hasNext() {
                return pointer != null;
            }

            @Override
            public Integer next() {
                int v = pointer.value;
                pointer = pointer.next;
                return v;
            }
        };
    }

    //结点类
    //做成内部类，以此来对外隐藏
    private static class Node {
        int value; // 值
        Node next; // 下一个结点指针

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }

    //向链表中添加元素
    public void addFirst(int value) {
        //链表为空
//        head = new Node(value, null);
        //链表非空
//        head = new Node(value, head);
        insert(0,value);
    }

    //使用函数式接口遍历链表
    public void loop1(Consumer<Integer> consumer) {
        Node pointer = head;
        while (pointer != null) {
            consumer.accept(pointer.value);//consumer接受数据
            pointer = pointer.next;//指针移动
        }
    }
    public void loop2(Consumer<Integer> consumer) {
        for (Node pointer = head.next; pointer != null; pointer = pointer.next) {
            consumer.accept(pointer.value);
        }
    }

    //寻尾部结点对象
    public Node findLast(){
        for(Node pointer = head.next;; pointer = pointer.next) {
            if(pointer.next == null){
                return pointer;
            }
        }
    }

    //尾插法
    public void addLast(Integer value) {
        Node last = findLast();
        //插入
        last.next = new Node(value, null);
    }

    //获取结点索引值
    public Node findNode(int index){
        //哨兵为 -1 索引
        int i = -1;
        for(Node pointer = head; pointer != null; pointer = pointer.next,i++) {
            if(i == index){
                return pointer;
            }
        }
        return null;
    }

    //返回某一位置索引值
    public int get(int index) throws IllegalArgumentException{
        Node node = findNode(index);
        if(node == null) {
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index));
        }
        return node.value;
    }

    //向索引位置插入
    public void insert(int index, int value) throws IllegalArgumentException{
        Node node = findNode(index - 1);
        if(node == null){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index - 1));
        }
        node.next = new Node(value, node.next);
    }

    //删除第一个节点
    public void removeFirst() throws IllegalArgumentException{
//        if(head == null){
//            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", 0));
//        }
//        head = head.next;
        remove(0);
    }

    //删除指定结点索引元素
    public Node remove(int index){
        Node node = findNode(index - 1);
        if(node == null){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index - 1));
        }
        Node removed = node.next;
        if(removed == null){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index - 1));
        }
        node.next = node.next.next;
        return removed;
    }

    //递归遍历
    private void recursion(Node curr){
        if(curr == null){
            return ;
        }
        System.out.println(curr.value);
        recursion(curr.next);
    }
    public void loop3(){
        recursion(head);
    }
}

三.双向链表的实现：

每个节点有两个指针，一个指向前一个节点，一个指向下一个节点。 

 

首先创建节点类以及对应的构造方法：

static class Node{
    int value;//值
    Node next;//下一个结点
    Node prev;//上一个结点
    public Node(Node prev, int value , Node next) {
        this.prev = prev;
        this.value = value;
        this.next = next;
    }
}

 然后创建头尾哨兵，便于在两哨兵中间插入元素以及双向链表的操作：

private Node head;//头哨兵
private Node tail;//尾哨兵

随后创建这个双向链表的构造方法：

//头 <=> 尾
public DoubleLinkedListSentinel() {
    head = new Node(null, 0, null);
    tail = new Node(null, 0, null);
    head.next = tail;
    tail.prev = head;
}

最后实现对双向链表的操作： 

package LinkListStudy;

import java.util.Iterator;

public class DoubleLinkedListSentinel implements Iterable<Integer>{

    static class Node{
        int value;//值
        Node next;//下一个结点
        Node prev;//上一个结点
        public Node(Node prev, int value , Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    //哨兵
    private Node head;//头哨兵
    private Node tail;//尾哨兵

    //头 <=> 尾
    public DoubleLinkedListSentinel() {
        head = new Node(null, 0, null);
        tail = new Node(null, 0, null);
        head.next = tail;
        tail.prev = head;
    }

    //根据索引位置找到结点
    private Node findNode(int index){
        int i = -1;
        //当p = tail时停止循环
        for(Node p = head; p != tail; p = p.next){
            if(i == index){
                return p;
            }
        }
        return null;
    }

    //在指定位置插入结点
    public void insert(int index , int value) throws IllegalArgumentException{
        Node prev = findNode(index - 1);
        if(prev == null){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index - 1));
        }
        Node next = prev.next;
        Node newNode = new Node(prev, value, next);
        prev.next = newNode;
        next.prev = newNode;
    }

    //删除指定位置的结点
    public void remove(int index) throws IllegalArgumentException{
        Node prev = findNode(index - 1);
        if(prev == null){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index - 1));
        }
        Node remove = prev.next;
        if(remove == tail){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", index));
        }
        Node next = remove.next;
        //断开联系
        prev.next = next;
        next.prev = prev;
    }

    //在尾部结点前添加结点
    public void addLast(int index , int value) throws IllegalArgumentException{
        Node last = tail.prev;
        Node newNode = new Node(last, value, tail);
        last.next = newNode;
        tail.prev = newNode;
    }

    //删除最后一个结点
    public void removeLast() throws IllegalArgumentException{
        //没有结点的情况
        if(tail.prev == head){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", 0));
        }
        Node remove = tail.prev;
        Node prev = remove.prev;
        prev.next = null;
        tail.prev = prev;
    }

    //迭代器
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = head.next;
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }

}

四.双向循环链表的实现：

链表的最后一个节点指向第一个节点，形成一个闭环。

 

 首先创造哨兵结点以及其构造函数：

    private static class Node{
        Node prev;
        int value;
        Node next;
        public Node(Node prev, int value , Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    //哨兵节点
    private Node sentinel = new Node(null, -1, null);
    //哨兵节点构造函数
    public DoubleLinkedListCirtleSentinel(){
        sentinel.prev = sentinel;
        sentinel.next = sentinel;
    }

随后实现对双向循环链表的操作： 

package LinkListStudy;

import java.util.Iterator;

public class DoubleLinkedListCirtleSentinel implements Iterable<Integer>{


    private static class Node{
        Node prev;
        int value;
        Node next;
        public Node(Node prev, int value , Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    //哨兵节点
    private Node sentinel = new Node(null, -1, null);
    //哨兵节点构造函数
    public DoubleLinkedListCirtleSentinel(){
        sentinel.prev = sentinel;
        sentinel.next = sentinel;
    }

    //添加节点到第一个   a <=> newNode <=> a(b)
    public void addFirst(int value){
        Node a = sentinel;//哨兵
        Node b = sentinel.next;
        Node newNode = new Node(a, value, b);
        a.next = newNode;
        b.prev = newNode;
    }

    //添加节点到最后一个
    public void addLast(int value){
        Node b = sentinel;
        Node a = sentinel.prev;
        Node newNode = new Node(a, value, b);
        a.next = newNode;
        b.prev = newNode;
    }

    //删除第一个
    public void removeFirst(){
        Node removed = sentinel.next;
        if(removed == sentinel){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", 0));
        }
        Node a = sentinel;
        Node b = removed.next;
        a.next = b;
        b.prev = a;
    }

    //删除最后一个
    public void removeLast() throws IllegalArgumentException{
        Node removed = sentinel.prev;
        if(removed == sentinel){
            throw new IllegalArgumentException(String.format("Index %d 不合法%n ", 0));
        }
        Node a = removed.next;
        Node b = sentinel;
        a.next = b;
        b.prev = a;
    }

    //根据目标值删除
    public void removeByValue(int value){
        Node removed = findByValue(value);
        if(removed == null){
            return ;//不用删
        }
        Node a = removed.prev;
        Node b = removed.next;
        a.next = b;
        b.prev = a;
    }

    //寻找目标值索引位置
    public Node findByValue(int value){
        Node p = sentinel.next;
        while(p != sentinel){
            if(p.value == value){
                return p;
            }
            p = p.next;
        }
        return null;
    }

    //迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = sentinel.next;

            @Override
            public boolean hasNext() {
                return p != sentinel;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }
    
    //递归函数
    private void recursion(Node curr){//某个节点要进行的操作
        if(curr == sentinel){
            return ;
        }
        System.out.println(curr.value);
        recursion(curr.next);
    }

}

好了，看到这里感谢观看，记得三连支持，后序继续更新数据结构与算法相关知识！！！

记得开心一点嘛
关注
专栏目录
单向循环链表和双向循环链表的结构分析
派拉斯兔子的博客
10-23 1071
单向循环链表： 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 单向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表： 双向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表直接体现为 双向和循环，一般的单链表只有节点数据data和next指向地址(应该也是引用的意思)，而在此需要增加前面部分的pre指向地址，同时还需要循环循环则在定义节点时可以解决，
【Java 数据结构】单向链表和双向链表的实现 (LinkedList)
热门推荐
书生-w的博客
04-16 1万+
​首先我们和ArrayList一样，将MySingleList单独定义为一个Java文件，然后每一个结点我们将它定义成一个静态内部类，这样就方便我们访问结点的成员，，还是和ArrayList一样，我们再定义一个Test类用来测试我们的单链表，写一个函数可以测试一下
java数组和链表底层_链表的底层原理和实现
weixin_42526166的博客
02-17 1194
一、简介本文从链表的简介开始，介绍了链表的存储结构，并根据其存储结构分析了其存储结构所带来的优缺点，进一步我们通过代码实现了一个输入我们的单向链表。然后通过对递归过程和内存分配的详细讲解让大家对链表的引用和链表反转有一个深入的了解。单向链表实现了两个版本，分别使用循环和递归实现了两个版本的链表，相信大家仔细阅读本文后会对链表和递归有一个深刻的理解。再也不怕面试官让手写链表或者反转链表了。后面会持续...
Java_简单实现无头单向非循环链表_简单实现LinkedList
weixin_66484088的博客
02-03 710
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度@Override@Override@Override@Override@Override@Override@Overridereturn 0;@Override@Override节点类包含存储数据和下一个节点引用。//头插法//尾插法。
数据结构——单链表与双链表（java实现）
2301_77993957的博客
07-15 1190
链表是线性表的一种，在物理存储结构上不一定连续（绝大多数情况下非连续），在数据逻辑顺序上，将节点用指针链接起来实现连续。链表是由一个一个的节点组成节点：节点中分为数据域与指针域，数据域用于存放数据，指针域用于存放下一个节点的引用地址。
【数据结构Java版】链表之单链表的实现
m0_63372226的博客
10-17 1178
如何定义一条链表。何如遍历链表，按照从前到后的顺序，依次访问链表中的元素。打印一条链表（依赖遍历链表中的所有元素）查找链表中存在的某个元素【目前只能做到从前往后遍历，无法做到从后往前遍历（代价很大）】找到链表从前往后数，第n个结点（元素）的操作。找到链表从后往前数，第n个结点（元素）的操作。关于链表的插入、删除操作。头插、头删。尾插、尾删。ArrayList的缺陷（1）链表的概念及结构（2）链表的类型1.单向or双向2.带头结点or不带头结点3.循环or不循环1.定义链表2.遍历链表
LinkedList底层实现（双向链表）（10）
帅哥威的博客
04-21 3902
LinkList说明流程一、介绍1、1 什么是LinkList(来源)1、2 LinkList是用来解决什么的？（作用）1、3 如何实现LinkList（原理）二、设计2、1 设计理念（理念）2、2 设计图（模型）三、实现3、1 Add(增)3、2 Remove（删）3、3 Get（查）四、使用4、1使用gif 一、介绍 1、1 什么是LinkList(来源) 1、2 LinkList是用来解决什...
java源码系列：LinkedList的底层实现原理和特性
鲁迷那的专栏—坚持实践后再写出来！
08-16 619
开启快速了解 链表 、LinkedList的底层实现原理和特性之旅。。。
python双向链表以及双向循环链表
tt丫的博客
01-29 1754
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 目录 一、双向链表和双向循环链表概念 二、双向链表的实现 1、建立节点对象 2、链表对象的初始定义 3、判断链表是否为空 4、获取链表长度 5、向头部添加节点 6、向尾部添加节点 7、指定位置插入节点 8、删除指定位置的节点 9、查找是否有该数据的节点 10、遍历输出整个链表 11、输入数据创建链表 12、具体调用 三、双向循环链表的实现 1、建立节点对象 2
java双向链表的长度_双向链表的原理与实现
weixin_39800990的博客
02-25 347
一、双向链表原理顾名思义，双向链表跟单链表和循环列表最大的差别，就是同时拥有前驱指针和后驱指针，基于这一个特性，查询某结点的前一个结点，时间复杂度可以达到O(1)，非常高效。双向链表的存取时间复杂度是O(n)，增删时间复杂度为O(1)，跟其他链表没啥区别。双向链表表示意图：双向链表.jpg所以双向链表的结点定义如下：class Node{Object data; //元素值Node pre; //...
Java集合，HashMap底层实现和原理（1.7数组+链表与1.8+的数组+链表+红黑树） 数组和链表.pdf
04-18
Java集合，HashMap底层实现和原理（1.7数组+链表与1.8+的数组+链表+红黑树） 在Java集合中，HashMap是一个常用的数据结构，它基于Map接口实现，元素以键值对的方式存储，并且允许使用null键和null值。由于key不允许...
hashmap是单向链表吗_Java集合，HashMap底层实现和原理（1.7数组+链表与1.8+的数组+链表+红黑树）...
weixin_39947961的博客
12-22 713
概述文章的内容基于JDK1.7进行分析，之所以选用这个版本，是因为1.8的有些类做了改动，增加了阅读的难度，虽然是1.7，但是对于1.8做了重大改动的内容，文章也会进行说明。HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null 建和null　值，　因为key不允许重复，因此只能有一个键为null,另外HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不能相同...
hashmap是单向链表吗_HashMap学习 — 单向列表转化为双向列表
weixin_39737951的博客
12-22 2396
一、概览HashMap的某个桶位如果存储的是单向列表，当向这个桶位继续插入一个元素的时候，这个桶位元素的数量超过8时，单项列表会转化为红黑树(同时是一个双向列表，jdk1.8之后)，且会先转化为双向列表：二、转化过程1，运行如下程序，使map底层数组的某个桶位的单向列表”开始“转化为红黑树按道理，当map-put的元素超过 8*100 = 800时才会扩容数组，所以，当map.put(65, "6...
Java就业冲刺之数据结构-递归-双向链表-树
m0_72568513的博客
07-04 183
删除的节点只有一颗子树,让该节点的父节点的left/right,指向删除节点的子节点即可。删除的节点有两颗子树,让删除节点的前驱节点/后继节点来替换该节点,才能保证树已让是有序的。删除的是叶子节点,此时直接删除即可,让其父节点指向该节点的引用置为null,即可。增删元素:(默认在尾部添加)将链断开,然后重新链接,从而实现添加/删除元素。为了避免失衡二叉树,对二叉排序树进行了优化,产生了两种新的数据结构。查找元素: get(int index):E。Comparator–外比较器。
工厂模式的介绍及实现
户伟伟的博客
09-25 145
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 348
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
java将word转pdf
紫月7575的博客
09-30 265
java将word转pdf
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 488
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
JPA+Thymeleaf增删改查
y050505的博客
09-25 495
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

记得开心一点嘛

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

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

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

打赏作者

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

抵扣说明：

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

余额充值