Java数据结构 - 链表与MyLinkedList

已于 2022-12-23 17:10:53 修改
阅读量222 收藏 3
点赞数 1
分类专栏： 数据结构(JAVA语言) 文章标签： java 数据结构 链表
于 2022-12-23 11:42:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jiali_1/article/details/128417694
版权

Java数据结构 - 链表

1. 链表的概念及结构

链表是一种线性的数据结构，由有限的结点组成。其特点是结点的物理存储结构不一定连续，但逻辑顺序是连续的，通过链表中的引用链接次序实现。

在这里插入图片描述
在这里插入图片描述

  1. 从图中可以看到结点的逻辑顺序是连续的，但物理地址不一定是连续的。
  2. 每个结点都是通过new创建的，在堆上开辟内存空间。
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

2. 不同的链表结构类型

实际中的链表多种多样，组合起来一共有8种类型。

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述

虽然链表的结构类型有这么多，但是我们主要掌握两种：

  • 无头单向非循环链表：结构简单，一般不会单独用来存储数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。且这种结构在笔试面试中出现居多。

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

3. 实现一个简单的MyLinkedList

在这里，我们以无头双向链表为例，编写一个自己的MyLinkedList类。我们知道MyLinkedList是一个容器类，类中包含一个结点内部类，通过实例化该内部类来创建结点对象。MyLinkedList类中还具有对结点增删改查等的方法，类似ArrayList实现类，只是底层数据存储的结构不同。

因为前面已经学过了泛型知识，所以实现MyLinkedList为泛型类。

public class MyLinkedList<E>{
    
    //结点内部类，包含结点实际存储元素和一对引用，分别指向上一个结点和下一个结点。
    private static class Node<E>{
        E element;
        Node<E> prev;
        Node<E> next;
        
        Node(E e){
            this.element = e;
        }
        
        Node(E e, Node<E> prev, Node<E> next){
            this(e);
            this.prev = prev;
            this.next = next;
        }
    }
    
    private int size; //记录当前结点数
    
    private Node<E> head; //标记当前头结点
    
    private Node<E> tail; //标记当前尾结点
    
    
    /**
    	头插法，在当前链表头部插入一个新结点，然后修改指向，使新结点成为头结点。
    */
    public void addFirst(E e){
        Node newNode = new Node(e);
        if(head == null){
            head = newNode;
            tail = newNode;
        }else{
			newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        size++;
    }
    
    /**
     	尾插法，在当前链表的尾部插入一个新结点，然后修改尾结点指向。
     */
    public void addLast(E e){
        Node<E> newNode = new Node<>(e);
        if(head == null){
            head = newNode;
        }else{
            tail.next = newNode;
            newNode.prev = tail;
        }
        tail = newNode;
        size++;
    }
    
    /**
    	索引插法，在当前链表的逻辑索引处插入一个新结点
    */
    public void addIndex(int index, E e){
        if(index < 0 || index > size){ //索引检查
            throw new IndexOutOfBoundsException("Index: " + index + ",Size: " + size);
        }

        if(index == 0){ //头插
            addFirst(e);
            return;
        }
        if(index == size){//尾插
            addLast(e);
            return;
        }
        Node<E> newNode = new Node<>(e);
        Node<E> indexNode = findIndexNode(index); //找到当前索引位置的结点
        //修改指向
        newNode.prev = indexNode.prev;
        newNode.next = indexNode;
        indexNode.prev.next = newNode; //或者newNode.prev.next = newNode;
        indexNode.prev = newNode; //或者newNode.next.prev = newNode;
        size++; 
    }

    private Node<E> findIndexNode(int index){
        Node<E> cur = head;
        while(index != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }
    
    /*
    	查询链表当中是否包含指定key
    */
    public boolean contains(E key){
        if(size == 0){
            return false;
        }
        Node<E> cur = head;
        while(cur != null){
            if(cur.element.equals(key)){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    
    /*
       删除链表当中第一次出现的key
	*/
    public E remove(E key){
        Node<E> cur = head;
        E oldElement = null;
        while(cur != null){
            if(cur.element.equals(key)){
                oldElement = cur.element; //保存删除的key

                if(cur == head){ //要删除的是头结点
                    head = head.next;
                    if(head != null){ //若头节点后面有结点
                        head.prev = null;
                    }else{
                        tail = null; //头节点后面无结点
                    }
                }else{ //要删除的是不是头结点
                    cur.prev.next = cur.next;
                    if(cur.next != null){ //要删除的不是尾结点
                        cur.next.prev = cur.prev;
                    }else{
                        tail = cur.prev; //要删除的是尾结点
                    }
                }
                size--;
                break;
            }
            cur = cur.next;
        }
        return oldElement;
    }

       
    /*
    	删除链表当中的所有key
    */
    public void removeAll(E key){
        Node<E> cur = head;
        while(cur != null){
            if(cur.element.equals(key)){
                if(cur == head){ //要删除的是头结点
                    head = head.next;
                    if(head != null){ //若头节点后面有结点
                        head.prev = null;
                    }else{
                        tail = null; //头节点后面无结点
                    }
                }else{ //要删除的是不是头结点
                    cur.prev.next = cur.next;
                    if(cur.next != null){ //要删除的不是尾结点
                        cur.next.prev = cur.prev;
                    }else{
                        tail = cur.prev; //要删除的是尾结点
                    }
                }
                size--;
            }
            cur = cur.next;
        }
    }
    
    /*
    	清空链表
    */
    public void clear(){
        Node<E> cur = head;
        while(cur != null){
            Node<E> curNext = cur.next;
            cur.prev = null;
            cur.next = null;
            cur = curNext;
        }
        head = null;
        tail = null;
    }
    
     /*
        打印当前链表的所有结点对象
     */
    public void display(){
        Node<E> cur = head;
        while(cur != null){
            System.out.println(cur.element);
            cur = cur.next;
        }
    }

    /*
        获取当前链表的结点个数
     */
    public int size(){
        return size;
    }

    /*
        返回当前链表是否为空链表
     */
    public boolean isEmpty(){
        return size == 0;
    }
    
}

4. MyLinkedList源码解读

1、结点内部类。

当我们添加结点的时候，就是new了这个结点类的对象，然后将该对象的前后结点引用链接到其他结点上。

private static class Node<E>{
    E element;
    Node<E> prev;
    Node<E> next;
        
    Node(E e){
        this.element = e;
    }
        
    Node(E e, Node<E> prev, Node<E> next){
        this(e);
        this.prev = prev;
        this.next = next;
    }
}

在这里插入图片描述

补充：为什么使用静态内部类？原因：如果使用普通内部类，创建其对象时依赖于外部类的实例，可以先理解为隐性引用着外部类实例。当想释放外部类的时候，GC无法对外部类对象进行回收，因为它还被引用着，如果不处理会导致后期内存泄漏。所以使用静态内部类的话，它不依赖于外部类，没有这种引用关系，能被各自回收。

2、size，head，tail 属性

这几个属性记录着当前MyLinkedList对象实体内存储的结点信息。

private int size; //记录当前结点数

private Node<E> head; //标记当前头结点

private Node<E> tail; //标记当前尾结点

3、addFirst头插法

首先new一个新结点并初始化结点值。如果当前添加是链表首次添加元素，使头尾指针引用当前新结点；如果当前链表有结点，使新结点的next引用头结点并让头结点的prev引用新结点，然后修改头结点指向，尾结点指向不变。

public void addFirst(E e){
    Node newNode = new Node(e);
    if(head == null){
        head = newNode;
        tail = newNode;
    }else{
        newNode.next = head;
        head.prev = newNode;
        head = newNode;
    }
}

在这里插入图片描述

4、addLast尾插法

与addFirst前半段一样，首先new一个新结点并初始化结点值。如果链表为空则直接使头尾指针引用当前新结点；如果链表有结点，让尾结点的next引用新结点，新结点的prev引用尾结点，然后修改尾结点指向。

public void addLast(E e){
    Node<E> newNode = new Node<>(e);
    if(head == null){
        head = newNode;
    }else{
        tail.next = newNode;
        newNode.prev = tail;
    }
    tail = newNode;
    size++;
}

在这里插入图片描述

5、addIndex索引插法

这里的索引并不真实存在与链表中，而是代表链表的逻辑索引，即第一个结点索引为0，第二个为1，以此类推。这里当我们要在指定索引插入新结点时可以分为几个步骤：

  1. 首先要对index进行检查，如果index不在当前有效范围之中就会抛异常。

  2. 若index为0，则进行头插法；若为size，则进行尾插法。

    注意：不能省略return语句

  3. 若index不为两侧任一侧，则要插入的索引位置在两侧之中，我们首先找到index位置的结点，然后修改指向，这里需要分别修改四个指向

    1. 首先使新结点的prev链接上indexNode前侧的结点。

      (一定不要先把indexNode的prev指向新结点，这样会丢掉indexNode前侧结点的链接)。

    2. 再将新结点的next链接上indexNode。

    3. …

    4. …

    这里的2~3步方法不唯一，可根据习惯来。

  4. 我们可以把查询索引位置结点的操作分离出来，作一个新方法。即解耦，减少代码耦合。

public void addIndex(int index, E e){
    if(index < 0 || index > size){ //索引检查
        throw new IndexOutOfBoundsException("Index: " + index + ",Size: " + size);
    }

    if(index == 0){ //头插
        addFirst(e);
        return;
    }
    if(index == size){//尾插
        addLast(e);
        return;
    }
    Node<E> newNode = new Node<>(e);
    Node<E> indexNode = findIndexNode(index); //找到当前索引位置的结点
    //修改指向
    newNode.prev = indexNode.prev;
    newNode.next = indexNode;
    indexNode.prev.next = newNode; //或者newNode.prev.next = newNode;
    indexNode.prev = newNode; //或者newNode.next.prev = newNode;
    size++; 
}

private Node<E> findIndexNode(int index){
    Node<E> cur = head;
    while(index != 0){
        cur = cur.next;
        index--;
    }
    return cur;
}

在这里插入图片描述

6、contains方法

查找当前链表中是否包含key对象结点，从头遍历链表并使用equals方法来判断对象是否相等。

public boolean contains(E key){
    if(size == 0){
        return false;
    }
    Node<E> cur = head;
    while(cur != null){
        if(cur.element.equals(key)){
            return true;
        }
        cur = cur.next;
    }
    return false;
}

在这里插入图片描述

7、remove方法

删除key对象结点的情况有四种，具体可以看下面的解析图。

/*
   删除链表当中第一次出现的key
*/
public E remove(E key){
    Node<E> cur = head;
    E oldElement = null;
    while(cur != null){
        if(cur.element.equals(key)){
            oldElement = cur.element; //保存删除的key

            if(cur == head){ //要删除的是头结点
                head = head.next;
                if(head != null){ //若头节点后面有结点
                    head.prev = null;
                }else{
                    tail = null; //头节点后面无结点
                }
            }else{ //要删除的是不是头结点
                cur.prev.next = cur.next;
                if(cur.next != null){ //要删除的不是尾结点
                    cur.next.prev = cur.prev;
                }else{
                    tail = cur.prev; //要删除的是尾结点
                }
            }
            size--;
            break;
        }
        cur = cur.next;
    }
    return oldElement;
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

8、removeAll方法

这个方法的操作逻辑与remove方法基本一致，只不过当删除一个key之后不会直接跳出循环，而是使cur遍历到末尾，直到删除了所有的key，或者当前链表中不存在key对象。

/*
    删除链表当中所有的key
*/
public void removeAll(E key){
    Node<E> cur = head;
    while(cur != null){
        if(cur.element.equals(key)){
            if(cur == head){ //要删除的是头结点
                head = head.next;
                if(head != null){ //若头节点后面有结点
                    head.prev = null;
                }else{
                    tail = null; //头节点后面无结点
                }
            }else{ //要删除的是不是头结点
                cur.prev.next = cur.next;
                if(cur.next != null){ //要删除的不是尾结点
                    cur.next.prev = cur.prev;
                }else{
                    tail = cur.prev; //要删除的是尾结点
                }
            }
            size--;
        }
        cur = cur.next;
    }
}

8、clear方法

清空当前链表中的所有结点，我们从头结点开始，依次断开与前后结点的链接，注意，要先保存一下当前结点之后的结点引用，不然会丢掉后面结点引用。

public void clear(){
    Node<E> cur = head;
    while(cur != null){
        Node<E> curNext = cur.next;
        cur.prev = null;
        cur.next = null;
        cur = curNext;
    }
    head = null;
    tail = null;
}

在这里插入图片描述

在这里插入图片描述

5、概念面试题

数组和链表的区别是什么？顺序表和链表的区别是什么？ArrayList和LinkedList的区别是什么？

其实这三个问题本质上是一个问题。

我们可以从两者的异同点来解释：

1、从数据结构的角度来说：

顺序表和链表是线性表的两种不同的存储结构，链表是各结点的物理地址不一定连续，但逻辑顺序连续，链表主要分为两种：单向链表和双向链表，就拿双向链表来说，其表中的每个结点都有一对引用，分别指向该结点的前驱结点和后继结点。顺序表则是用一段地址连续的存储单元依次存放表中的数据元素。

2、从对元素增删改查的角度来说：

在数组中插入或删除一个元素时，时间复杂度为O(N)，因为在i下标位置插入或删除一个元素时，需要移动N-i个元素，插入或删除元素时间O(1)+移动元素时间O(n-i)最坏时可以达到O(N)，而相比，在链表头结点位置插入或删除一个元素时，时间复杂度仅为O(1)，因为只需要修改头结点的引用指向，不用去移动任何元素。

在数组中查找或修改一个元素时，时间复杂度为O(1)，因为数组默认是实现了RandomAccess接口，支持随机访问，通过数组下标可以直接访问到指定索引元素。而在链表中查找或修改一个元素时（不知道前驱结点的情况下），时间复杂度可以达到O(N)，因为链表不能被随机访问，想要访问链表中间结点的位置，必须要先从头或尾结点开始。

3、从存储空间使用上来讲：

数组会浪费更多的空间，因为数组的长度是创建时指定的，当实际存储元素数量没有达到开始时指定的长度时，就会造成浪费。而且当长度不够时，还需要进行扩容，扩容时需要移动之前所有元素到新开辟的堆空间上，又会浪费不少时间。相比较链表来说，每个结点只需要多一个或一对引用变量，用来存储后一个或前后结点的地址，且链表没有长度的概念，使用时不用考虑事先开辟多大的空间，而是随用随取，空间浪费相对于数组来讲很小。

总的来说，当具体的业务频繁增删元素时，建议使用链表。当只需要查改指定元素时，建议使用数组。

在i下标位置插入或删除一个元素时，需要移动N-i个元素，插入或删除元素时间O(1)+移动元素时间O(n-i)最坏时可以达到O(N)，而相比，在链表头结点位置插入或删除一个元素时，时间复杂度仅为O(1)，因为只需要修改头结点的引用指向，不用去移动任何元素。

在数组中查找或修改一个元素时，时间复杂度为O(1)，因为数组默认是实现了RandomAccess接口，支持随机访问，通过数组下标可以直接访问到指定索引元素。而在链表中查找或修改一个元素时（不知道前驱结点的情况下），时间复杂度可以达到O(N)，因为链表不能被随机访问，想要访问链表中间结点的位置，必须要先从头或尾结点开始。

3、从存储空间使用上来讲：

数组会浪费更多的空间，因为数组的长度是创建时指定的，当实际存储元素数量没有达到开始时指定的长度时，就会造成浪费。而且当长度不够时，还需要进行扩容，扩容时需要移动之前所有元素到新开辟的堆空间上，又会浪费不少时间。相比较链表来说，每个结点只需要多一个或一对引用变量，用来存储后一个或前后结点的地址，且链表没有长度的概念，使用时不用考虑事先开辟多大的空间，而是随用随取，空间浪费相对于数组来讲很小。

总的来说，当具体的业务频繁增删元素时，建议使用链表。当只需要查改指定元素时，建议使用数组。

文章为本人独立编写，难免会有错误之处。
如发现有误，恳请评论提出！

默默地敲出Bug
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 | 链表LinkedList(Java实现)
xxzaa的博客
04-19 472
链表（重要+困难） 对链表这种数据结构的理解 对引用和对象的理解
数据结构之--双链表MyLinkedList
apple3515的博客
03-24 121
　　双链表的手动实现中考虑三个类的实现： 1、MyLinkedList类本身的实现，包含到两端的链、表的大小以及一些方法。 2、Node节点，它可能是一个私有的内部嵌套类，这个类，嵌套在MyLinkedList的内部，数据域：data，前驱指针prev和后继指针next，以及合适的构造方法 3、LinkedListIterator类，该类抽象了位置的概念，是一个实现了Iterato...
单链表结构实现和循环链表及双向链表的定义
qq_42932834的博客
06-06 943
单链表基础结构实现 这里我并没有写增删改查的功能，参考了数据结构严蔚敏版一书。然后我发现按他的那段初始化伪代码实现后，结点倒过来了，不过并不影响道理。 重点需要搞清楚单链表的结构，C好久没用去学面向对象了，结构体和malloc我有点忘记了，码在这里以后忘了当参考。 #include <iostream> #include <cstdio> #include <cs...
链表MyLinkedList的代码实现
web教程
07-05 254
一、需要实现的几个API 二、构造函数 链表为空时：head tail 2. getNode(index) 3. 检查索引是否合法 四、增删查改 1. 增 链表头部插入节点x 链表尾部插入节点x 在索引index处插入节点x 2. 删 删除第一个节点 删除最后一个节点 删除索引index对应的节点 3. 查 查找第一个元素 查找最后一个元素 查找索引为index的元素 4. 改 ...
Java链表：实现MyArrayList和MyLinkedList
Yan__Ran的博客
06-18 469
目录一、线性表1、Interface：MyList2、Class：MyArrayList（1）关于MyArrayList的有参构造函数（2）检验数组是否full的函数ensureCapacity3、Class：MyLinkedList二、栈和队列（1）GenericQueue（2）GenericStack三、优先队列一个月前学习了线性表、栈、队列和优先队列的相关特性和接口、类中的方法。博客：Java数据结构：线性表、栈、队列和优先队列_颜 然的博客-CSDN博客 下面 --> 如何自己实现一个这样的数据结构
Java数据结构篇-链表与数组实现栈.pptx.pptx
最新发布
12-19
数据结构的定义 数据结构是计算机存储、组织数据的方式，用于高效地访问和修改数据。...Java提供了丰富的数据结构库，包括数组、链表、栈、队列等，这些数据结构为程序员提供了处理各种问题的工具和方法。
数据结构-链表(LingkedList)介绍和Java示例代码
07-01
链表是一种重要的线性数据结构，它与数组相比具有独特的特性和优势。链表由一系列节点构成，每个节点包含两部分：数据元素和指向下一个节点的引用。这种结构允许链表在内存中不连续分布，提供了动态扩展和收缩的能力...
链表_数据结构--链表_
10-01
在windows端利用python实现链表的相关功能
数据结构之LinkedList与链表
sniper_fandc的博客
03-22 1686
目录 1.LinkedList的特点和存在意义 2.LinkedList的简单使用 2.1.LinkedList的构造 2.2.常见方法 2.3.遍历 3.链表结构 4.简单实现 4.1单向无头不循环链表 4.2.双向无头不循环链表 5.ArrayList与LinkedList的不同 1.LinkedList的特点和存在意义 LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了...
边学边记——Java数据结构☞LinkedList（链表）的介绍及自我实现
lil_ghost_的博客
10-18 666
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。理论：链表也是一种线性表。线性表集合：逻辑上元素和元素有前后顺序，但不保证这些元素按照逻辑的顺序存储。自定义实现线性表（接口MyList）和链表表（类MyLinkedList）。
自定义LinkedList类（单链表）
Juily家的小蜜果
08-28 2626
自定义链表LinkedList，实现LinkedList的部分方法，理解LinkedList的方法原理。 一，定义节点类 package LinkedList; public class Node { private Object data;//定义数据域 private Node next;//注意这里的next的类型是Node //构造函数1，空节点 ...
Java数据结构--链表
weixin_56846554的博客
03-13 923
单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点由元素和指针构成。 元素表示数据元素的映象，就是存储数据的存储单元；指针指示出后继元素存储位置，就是连接每个结点的地址数据。 以结点的序列表示的线性表称作线性链表，也就是单链表，单链表是链式存取的结构。
Java数据结构-链表(LinkedList)(四)
weixin_45987961的博客
10-28 340
方式三、 什么是链表 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）； 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活； 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 1. 单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元
链表-----Java中LinkedList类的实现
分享点点滴滴的知识~
11-10 627
链表 LinkedList
Java集合类——LinkedList（单链表及双链表）
小小码农
12-29 1065
Java集合类——LinkedList（单链表及双链表）
【Java 数据结构】单向链表和双向链表的实现 (LinkedList)
热门推荐
书生-w的博客
04-16 1万+
​首先我们和ArrayList一样，将MySingleList单独定义为一个Java文件，然后每一个结点我们将它定义成一个静态内部类，这样就方便我们访问结点的成员，，还是和ArrayList一样，我们再定义一个Test类用来测试我们的单链表，写一个函数可以测试一下
Day11_8 Java学习之自定义LinkedList集合类
weixin_43717536的博客
08-11 821
解析：1.LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。2.需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素。3.它也是长度可变的集合，且集合也是元素有序可重复也是只能存引用数据类型。解析：1.从代码的角度来看，就是一个Node类，链表是由多个节点串起来的，链表又分单向链表与双向链表。...
【数据结构】链表LinkedList
qq_61862008的博客
11-18 1004
链表以及LinkedList介绍

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值