集合及数据结构第七节————LinkedList的模拟实现与使用

于 2024-08-21 09:40:42 发布
阅读量584 收藏 12
点赞数 23
分类专栏： 数据结构学习 文章标签： 数据结构 java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79418684/article/details/133513286
版权

系列文章目录

集合及数据结构第七节————LinkedList的模拟实现与使用

LinkedList的模拟实现与使用

  1. 无头双向链表实现
  2. 什么是LinkedList
  3. LinkedList的使用
  4. LinkedList的遍历
  5. ArrayList和LinkedList的区别

文章目录

一、LinkedList的模拟实现

1.无头双向链表实现

在这里插入图片描述

定义接口

public interface Ilist {

    public void addFirst(int data);//头插法


    public void addLast(int data);//尾插法


    public void addIndex(int index,int data);//任意位置插入,第一个数据节点为0号下标

    public boolean contains(int key);//查找是否包含关键字key是否在双向链表当中


    public void remove(int key);//删除第一次出现关键字为key的节点

    public void removeAllKey(int key); //删除所有值为key的节点

    public int size();//得到双向链表的长度

    public void clear() ;//清空链表

    public void display() ;//打印链表

}

定义双向链表的内部类

    static class ListNode {//将节点定义成内部类
        public int val;//数据域
        public ListNode next;//后驱节点（引用类型）
        public  ListNode prev;//前驱节点

        public ListNode(int val) {
            this.val = val;
            //没有初始化next默认为null（因为next是引用数据类型）
        }
    }

    public ListNode head;//头节点
    public ListNode last;//尾节点

接口的实现

头插法的时间复杂度为O（1）

头插法

思路：

第一次插入时head和last都指向这个节点
在这里插入图片描述

在这里插入图片描述
代码实现：

    public void addFirst(int data) {;//头插法
        ListNode node = new ListNode(data);//创建一个node节点用来存放插入的数据
        if(head == null){//插入第一个数据
            this.head = node;
            this.last = node;
        }else {//有其他节点，进行头插
            node.next = this.head;//先绑定后面更安全
            this.head.prev = node;
            this.head = node;
        }
    }
尾插法

尾插法的时间复杂度为O（1）

思路：

第一次插入时head和last都指向这个节点
在这里插入图片描述

在这里插入图片描述

代码实现：

    public void addLast(int data) {//尾插法
        ListNode node = new ListNode(data);//创建一个node节点用来存放插入的数据
        if(head == null){//插入第一个数据
            this.head = node;
            this.last = node;
        }else {//有其他节点，进行尾插
            last.next = node;//先绑定后面更安全
            node.prev = this.last;
            this.last = node;
        }
    }
任意位置插入,第一个数据节点为0号下标

思路：
在这里插入图片描述

  1. 检查index是否合法
  2. 找到cur节点（cur走index步 ）（新增一个private修饰的searchIndex方法来找到index位置节点）
  3. 插入node节点
public class AddIndexLocationWrong extends  RuntimeException{// 检查index是否合法（输入下标不合法）
    public AddIndexLocationWrong(String message){
        super(message);
    }
}

    private ListNode searchIndex(int index){//找到index位置节点
        ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
        //从而避免head = null的情况出现
        while (index != 0){
            cur = cur.next;//让cur指向下一个节点
            index--;
        }
        return cur;
    }

    public void addIndex(int index, int data) {;//任意位置插入,第一个数据节点为0号下标
        int len = size();
        if(index < 0 || index > len){//如果输入的index对应节点没有数据，抛出异常
            throw  new AddIndexLocationWrong("输入的index位置不合法" + index);
        }
        if (index == 0) {//在开头插入直接调用头插法
            addFirst(data);
            return;
        }
        if (index == len){//在结尾插入，直接调用尾插法
            addLast(data);
            return;
        }

        ListNode cur = searchIndex(index);//新建一个cur节点存放找到的index位置的节点
        ListNode node = new ListNode(data);//创建一个node节点用来存放插入的数据

        //插入数据（先修改next就一定不会出错）
        node.next = cur;//让node的next后驱指向cur
        cur.prev.next  = node;//让插入前cur的前一个节点的next后驱指向node
        node.prev = cur.prev;//让node的next前驱指向插入前cur的前一个节点
        cur.prev = node;//让cur的next前驱指向node
    }
查找是否包含关键字key是否在双向链表当中
   public boolean contains(int key) {//查找是否包含关键字key是否在单链表当中
        ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
        //从而避免head = null的情况出现
        while (cur != null){
            if (cur.value == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
删除第一次出现关键字为key的节点

思路：
一般情况下
在这里插入图片描述
删除的是第一个节点

在这里插入图片描述
在这里插入图片描述
删除最后一个节点
在这里插入图片描述

代码实现：

    public void remove(int key) {//删除第一次出现关键字为key的节点
        ListNode cur = this.head;
        while (cur != null){
            if(cur.val ==key) {//cur的val与key相等时
                if(cur == head){//删除的是第一个节点
                    head = head.next;//头节点向后移动（当链表中只有一个节点时，相当于把head置空让第一个节点不再被head引用）
                    if (head == null){//当链表中只有一个节点时
                                       // （不加这个判断条件会导致else中的语句在只有一个节点时,空指针异常）
                        last = null;//当链表中只有一个节点时,last置空让第一个节点不再被last引用
                    }else {
                        head.prev = null;//移动后的头节点的前驱置空（第一个节点不在被引用，会被自动化回收）
                    }

                }else {//删除的不是第一个节点
                    cur.prev.next = cur.next;//让cur的前一个节点的next后驱指向cur的后一个节点
                    if(cur.next == null){//删除的是最后一个节点,把last置空让第一个节点不再被last引用
                        last = last.prev;
                    }else {//删除的是中间节点
                        cur.next.prev = cur.prev;//让cur的后一个节点的前驱指向cur的前一个节点
                    }
                }
                return;//删除结束后退出
            }
            else {
                cur = cur.next;
            }
        }
    }
删除所有值为key的节点
    public void removeAllKey(int key) { //删除所有值为key的节点
        ListNode cur = this.head;
        while (cur != null){
            if(cur.val ==key) {//cur的val与key相等时（删完一个后不退出，直到遍历完整个链表）
                if(cur == head){//删除的是第一个节点
                    head = head.next;//头节点向后移动（当链表中只有一个节点时，相当于把head置空让第一个节点不再被head引用）
                    if (head == null){//当链表中只有一个节点时
                        // （不加这个判断条件会导致else中的语句在只有一个节点时,空指针异常）
                        last = null;//当链表中只有一个节点时,last置空让第一个节点不再被last引用
                    }else {
                        head.prev = null;//移动后的头节点的前驱置空（第一个节点不在被引用，会被自动化回收）
                    }

                }else {//删除的不是第一个节点
                    cur.prev.next = cur.next;//让cur的前一个节点的next后驱指向cur的后一个节点
                    if(cur.next == null){//删除的是最后一个节点,把last置空让第一个节点不再被last引用
                        last = last.prev;
                    }else {//删除的是中间节点
                        cur.next.prev = cur.prev;//让cur的后一个节点的前驱指向cur的前一个节点
                    }
                }
            }
                cur = cur.next;
        }
    }
得到双向链表的长度
        ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
        //从而避免head = null的情况出现
        int count = 0;//用来计数
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count ;
清空
  1. 直接把头节点和尾节点置空（不推荐）
  2. 把每个节点的每个域都置空
    public void clear() {//清空链表
      ListNode cur = head;
      while (cur != null){
          ListNode temp = cur.next;//让temp指向cur的后驱指向的节点，让清空操纵正常进行
          //cur.val = null;//
          cur.prev = null;
          cur.next = null;
          cur = temp;
      }
      head = null;
      last = null;
    }
打印链表的数据

要创建一个临时节点来替head节点完成工作，从而避免head = null的情况出现

public void display() {//打印链表的数据
    ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
    //从而避免head = null的情况出现
    while (cur != null){//打印的停止条件
        System.out.print(cur.value + " ");
        cur = cur.next;//让head指向下一个节点
    }
    System.out.println();
}

二、.LinkedList的使用

1.什么是LinkedList

LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
在这里插入图片描述
在集合框架中，LinkedList也实现了List接口，具体如下：
在这里插入图片描述

【说明】

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

2.LinkedList的使用（ * * ）

1. LinkedList的构造

在这里插入图片描述

public static void main(String[] args) {
	// 构造一个空的LinkedList
	List<Integer> list1 = new LinkedList<>();
	List<String> list2 = new java.util.ArrayList<>();
	list2.add("JavaSE");
	list2.add("JavaWeb");
	list2.add("JavaEE");
	// 使用ArrayList构造LinkedList
	List<String> list3 = new LinkedList<>(list2);
}

2. LinkedList的其他常用方法介绍

方法解释
void addLast(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

（? extends E）是指 ：？是不是E本身或者E的子类

首先创建一个Integer类型的链表表并存入一些数字，并打印一下链表的大小和链表

inkedList<Integer> list = new LinkedList<>();
            list.add(1); // add(elem): 表示尾插
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            list.add(6);
            list.add(7);
            System.out.println(list.size());
            System.out.println(list);

在这里插入图片描述

在起始位置插入0

            list.add(0, 0); // add(index, elem): 在index位置插入元素elem
            System.out.println(list);

在这里插入图片描述

remove(): 删除第一个元素，内部调用的是removeFirst()

			list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
            System.out.println(list);

在这里插入图片描述

removeFirst(): 删除第一个元素

			list.removeFirst(); // removeFirst(): 删除第一个元素
            System.out.println(list);

在这里插入图片描述

removeLast(): 删除最后元素

            list.removeLast(); // removeLast(): 删除最后元素
            System.out.println(list);

在这里插入图片描述

remove(index): 删除index位置的元素

            list.remove(1); // remove(index): 删除index位置的元素
            System.out.println(list);

在这里插入图片描述

contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false

            if(!list.contains(1)){//1如果不存在就进入if
                list.add(0, 1);
            }
            list.add(1);//内部调用的是linkLast(e);
            System.out.println(list);

在这里插入图片描述

indexOf(elem): 从前往后找到第一个elem的位置

            System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置

在这里插入图片描述

lastIndexOf(elem): 从后往前找第一个1的位置

System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置

在这里插入图片描述

get(index): 获取指定位置元素

            int elem = list.get(0); // get(index): 获取指定位置元素
            System.out.println(elem);

在这里插入图片描述

set(index, elem): 将index位置的元素设置为elem

            list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
            System.out.println(list);

在这里插入图片描述

subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回

            List<Integer> copy = list.subList(0, 3);
            System.out.println(list);
            System.out.println(copy);

            copy.add( 0,5656);
            System.out.println(list);
            System.out.println(copy);

在这里插入图片描述

将list中元素清空

            list.clear(); // 将list中元素清空
            System.out.println(list.size());

在这里插入图片描述

完整代码：

      public static void main(String[] args) {
            LinkedList<Integer> list = new LinkedList<>();
            list.add(1); // add(elem): 表示尾插
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            list.add(6);
            list.add(7);
            System.out.println(list.size());
            System.out.println(list);
// 在起始位置插入0
            list.add(0, 0); // add(index, elem): 在index位置插入元素elem
            System.out.println(list);
            list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
            list.removeFirst(); // removeFirst(): 删除第一个元素
            list.removeLast(); // removeLast(): 删除最后元素
            list.remove(1); // remove(index): 删除index位置的元素
            System.out.println(list);
// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
            if(!list.contains(1)){
                list.add(0, 1);
            }
            list.add(1);
            System.out.println(list);
            System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
            System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
            int elem = list.get(0); // get(index): 获取指定位置元素
            list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
            System.out.println(list);
// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
            List<Integer> copy = list.subList(0, 3);
            System.out.println(list);
            System.out.println(copy);
            list.clear(); // 将list中元素清空
            System.out.println(list.size());
    }

在这里插入图片描述

3.LinkedList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());

        //for循环+下标遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
// foreach遍历
        for (int e:list) {
            System.out.print(e + " ");
        }
        System.out.println();
// 使用迭代器遍历---正向遍历 要导包--》import java.util.ListIterator;
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();
// 使用反向迭代器---反向遍历   要导包--》import java.util.ListIterator;
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
            System.out.print(rit.previous() +" ");
        }
        System.out.println();
    }

在这里插入图片描述

三、ArrayList和LinkedList的区别

如果经常根据下标进行查找的，可以使用顺序表Array list。
如果经常进行插入和删除的，可以使用链表Linked list。
在这里插入图片描述

莲雾flops
关注
  • 23
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合及数据结构第六节————链表、单链表的实现和练习
2301_79418684的博客
08-21 746
链表、单链表的实现和练习 1. ArrayList的缺陷 2. 链表的概念及结构 3. 单链表的实现 4. 链表练习题
Java数据结构——第六节-LinkedList与链表
蓝天it（让亿万孩子在蓝天下共享优质教育）
07-17 146
Java链表
Java数据结构——第七节-栈和队列
蓝天it（让亿万孩子在蓝天下共享优质教育）
07-22 705
栈和队列
LinkedList与链表①——SingleLinkedList的模拟实现（简单）
m0_62379634的博客
04-24 534
LinkedList简介，底层，构造，常用方法，遍历。链表的概念及结构。SingleLinkedList模拟实现（简单）！！！
java数据结构与算法第四课——链表
baijaiyu的博客
05-18 1065
一：引入 上一课中我们介绍了顺序表，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。 为了解决这一问题，java集合中又引入了LinkedList，即链表结构。 二：链表 2.1链表的概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 链表.........
Java数据结构（三）——顺序表与ArrayList
xiaokuer_的博客
07-20 643
文章介绍顺序表的相关知识，包括List接口、ArrayList的构造、方法、遍历以及扩容机制，干货满满！
数据结构之二叉树详解——包含递归及迭代遍历方式
guojiaqi_的博客
08-12 956
二叉树（binary tree）是一种非线性数据结构，代表“祖先”与“后代”之间的派生关系，体现了“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含值、左子节点引用和右子节点引用。
数据结构入门到入土——链表（完）LinkedList
SixLegs的博客
01-09 1713
双向链表由一系列的节点组成，每个节点包含两个指针，分别指向前一个节点和后一个节点。与单向链表不同，双向链表可以从任意节点开始，向前或向后遍历链表。如下图所示：这是一个无头双向链表，从中我们不难看出它与无头单向链表的区别：1.不仅有头节点通过next进行顺序访问，还有尾节点通过prev进行逆序访问2.额外有一个prev域访问上一个已访问过的节点LinkedList的官方文档。
Java——LinkedList与链表介绍
华墨1024的博客
11-07 808
本文将对链表和LinkedList进行简要介绍
排序（归并排序，非比较排序）
qq_63074244的博客
08-20 547
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
【Java & 数据结构】初识二叉树
qq_42150700的博客
08-20 472
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
数据结构之树的存储结构
DKPT的博客
08-16 536
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
【数据结构入门】二叉树之堆的实现
最新发布
KevinRay_0854的博客
08-20 1075
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
数据结构【顺序结构二叉树：堆】（1）
qq_67578580的博客
08-20 610
堆排序时间复杂度计算。
C语言基础（六）
wehpd的博客
08-20 216
一维数组
数据结构day01（数据结构、算法基础知识）
dghbs的博客
08-20 768
数据结构就是数据的逻辑结构存储结构以及操作（类似数据的运算）数据结构的最终目的就是：如何更高效的存储数据算法对特定问题求解步骤的一种描述，它是指令的有限序列，期中每一条指令都表示一个或多个操作。数据结构 + 算法 = 程序。
从零开始学数据结构系列之第四章《拓扑排序代码详解》
铁匠匠匠的博客
08-16 1081
以上就是所有内容，对大家有用的话点个关注！我们拿这张图来进行代码详解。此时图的入度表更新为。此时图的入度表更新为。此时图的入度表更新为。此时图的入度表更新为。
C:每日一题：双指针法的使用
JonlyMay的博客
08-20 814
双指针法的使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值