数据结构：链表进阶

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

链表进阶

    • 1. ArrayList的缺陷
    • 2. 链表
      • 2.1 链表的概念及结构
      • 2.2 链表的实现
    • 3.链表面试题
    • 4.LinkedList的使用
      • 5.1 什么是LinkedList
      • 4.2 LinkedList的使用
    • 5. ArrayList和LinkedList的区别

1. ArrayList的缺陷

通过源码知道，ArrayList底层使用数组来存储元素：

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// ...
// 默认容量是10
private static final int DEFAULT_CAPACITY = 10;
//...
// 数组：用来存储元素
transient Object[] elementData; // non-private to simplify nested class access
// 有效元素个数
private int size;
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
}
// ...

由于其底层是一段连续空间，**当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，**效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。

2. 链表

2.1 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。在这里插入图片描述
链表的结构就类似于火车
在这里插入图片描述
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
1. 单向或者双向
在这里插入图片描述
2. 带头或者不带头
在这里插入图片描述
3. 循环或者非循环
在这里插入图片描述
虽然有这么多的链表的结构，但是我们重点掌握两种
无头单向非循环链表：结构简单，一般不会单独用来存数据。**实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。**另外这种结构在笔试面试中出现很多
在这里插入图片描述
无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

2.2 链表的实现

定义一个接口：

public interface IList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    //清空单链表
    public void clear();
    //遍历单链表
    public void display();
    //创建单链表
    public void  crate();
}

定义一个MySIngList类：
准备工作：MySingeList要继承IList接口的所有方法

public class MySingeList implements IList {
//定义单链表
    static class ListNode {
        public int val;
        public ListNode next;//next存的是下一个节点的地址，

        /**
         * 就相当于Person person=new person()，next是一个引用，
         * next存的是地址，next引用类型是ListNode类型的引用
         */
        public ListNode(int val) {//实例化
            this.val = val;
        }
    }
//定义一个头结点
    public ListNode head;

创建一个单链表：

    @Override
    public void crate() {
        ListNode listNode1 = new ListNode(11);//如何修改当前节点位置的next的值为指定节点位置
        ListNode listNode5 = new ListNode(22);
        ListNode listNode4 = new ListNode(33);
        ListNode listNode3 = new ListNode(44);
        ListNode listNode2 = new ListNode(55);

        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
        this.head = listNode1;//将插入的第一个节点定义为头节点
    }

遍历这个单链表：

  @Override
    public void display() {
        //定义一个cur，让cur去走，head不变，才能在遍历以后找到head
        ListNode car = head.next;
        while (car != null) {//判断是否遍历完链表
            System.out.println(car.val + " ");
            car = car.next;//如何从当前位置走到下一个节点位置
        }
    }

头插法：

  //头插法;时间复杂度：O(1)
    @Override
    public void addFirst(int data) {
        ListNode listNode = new ListNode(data);
        if (this.head == null) {
            this.head = listNode;
        } else {
            this.head = listNode.next;
            this.head = listNode;
        }
    }

不同位置添加的时间复杂度不同，常见的错误观点是认为所有添加操作都是O(1)。在尾部添加需要O(n)，头部添加为O(1)，在任意位置则平均为O(n)。了解这些有助于优化链表操作的效率。
尾插法：

 //尾插法时间复杂度：O(n)
    @Override
    public void addLast(int data) {
        ListNode car = this.head;
        ListNode listNode = new ListNode(data);
        if (this.head == null) {
            this.head = listNode;
        } else {
            //找到最后一个节点
            while (car.next != null) {
                car = car.next;
            }//car现在指向最后一个节点

            /**如果想让car停在最后一个节点的位置 cur.next！=null
             * 如果想把整个；链表的每一个节点都遍历完，那么就是car！=null
             * */
            car.next = listNode;
        }
    }

在链表尾部添加（addLast()）需要从头遍历，时间复杂度为O(n)

任意位置插入,第一个数据节点为0号下标：

//随便插入
private ListNode seach(int index) {
        ListNode car = this.head;
        int count = 0;
        while (count != index - 1) {
            car = car.next;
            count++;
        }
        return car;
    }
    @erride
    public void addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            System.out.println("不合法");
            throw new Poslllgality("插入元素下标异常" + data);
        }

        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode car = seach(index);
        ListNode node = new ListNode(data);
        node.next = car.next;
        car.next = node;

    }

当在任意位置插入的时候，要考虑的情况有很多：

  1. 当index < 0 || index > size()的时候，抛出一个异常
  2. 当index为0的时候，头插法
  3. 当index为size（）的时候，尾插法
  4. 正常的插入法

查找是否包含关键字key是否在单链表当中：

 @Override
    public boolean contains(int key) {
        ListNode car = this.head;
        while (car != null) {
            if (car.val == key) {
                return false;
            }
            car = car.next;
        }
        return false;
    }

删除第一次出现关键字为key的节点：

@Override
    public void remove(int key) {
        if (this.head == null) {
            System.out.println("无法删除");
        }
        if (this.head.val == key) {
            this.head = null;//或者this.head==this.head.next
        }
        ListNode car = searchprev(key);
        if (car == null) {
            System.out.println("没有要删除的数字");
            return;
        } else {
            ListNode del = car.next;//通过car.next找到del的位置
            car.next = del.next;//然后就可以自己看懂
        }

    }
    
    //写一个方法,找到关键字看的前一个节点的地址
    private ListNode searchprev(int key) {
        ListNode car = this.head;
        while (car.next != null) {
            if (car.next.val == key) {
                return car;
            }
            car = car.next;
        }
        return null;
    }

删除所有值为key的节点：

 @Override
    public void removeAllKey(int key) {
        if (this.head == null) {
            return;
        }
        ListNode prev = head;
        ListNode car = head.next;
        while (car != null) {
            if (car.val == key) {
                prev.next = car.next;
                car = car.next;
            } else {
                prev = car;
                car = car.next;
            }
        }
        if (head.val == key) {
            head = head.next;
        }
    }

得到单链表的长度：

 @Override
    public int size() {
        ListNode car = head.next;
        int count = 0;
        while (car != null) {
            count++;
            car = car.next;
        }
        return count;
    }

清空链表：

 @Override
    public void clear() {
        ListNode car = this.head;
        while (car != null) {
            ListNode carNext = car.next;//定义一个变量把car的next记录下
            /* car.val=null;如果是一个应用数据类型，那么才写这个，
            如果不是car.next=null就可以清除完毕
            */
            car.next = null;
            car = carNext;
        }
        head = null;//上面的循环走完，但是head还没有置空，要手动把head置空
    }

3.链表面试题

  1. 删除链表中等于给定值 val 的所有节点。 力扣
  2. 反转一个单链表。 力扣
  3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。力扣
  4. 输入一个链表，输出该链表中倒数第k个结点。 牛客
  5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。力扣
  6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。力扣

4.LinkedList的使用

5.1 什么是LinkedList



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

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

4.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);
}
  1. LinkedList的其他常用方法介绍
    在这里插入图片描述
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());
}
}
  1. LinkedList的遍历
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());
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
}
System.out.println();
}

5. ArrayList和LinkedList的区别

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/924581.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

DVWA 在 Windows 环境下的部署指南

DVWA 在 Windows 环境下的部署指南

目录预览 一、靶场介绍二、前置准备1. 环境准备2.靶场下载 三、安装步骤1.配置Phpstudy2.配置数据库3.配置DVWA4.登入DVWA靶场 四、参考链接 一、靶场介绍 DVWA 一共包含了十个攻击模块&#xff0c;分别是&#xff1a; Brute Force&#xff08;暴力&#xff08;破解&#xff…
阅读更多...
关于如何在k8s中搭建一个nsfw黄图鉴定模型

关于如何在k8s中搭建一个nsfw黄图鉴定模型

随着现在应用内图片越来越多&#xff0c;安全审查也是必不可少的一个操作了 下面手把手教你如何将huggingface中的黄图检测模型部署到自己的服务器上去 1.找到对应的模型 nsfw_image_detection 2.在本地先验证如何使用 首先安装transformers python库 pip install transform…
阅读更多...
【linux】tar命令讲解笔记

【linux】tar命令讲解笔记

Linux tar 命令 Linux tar&#xff08;英文全拼&#xff1a;tape archive &#xff09;命令用于备份文件。 tar 是 Linux 和 Unix 系统中用于归档文件和目录的强大命令行工具。 tar 名字来自 "tape archive"&#xff08;磁带归档&#xff09;&#xff0c;最初用于将…
阅读更多...
JVM_垃圾收集器详解

JVM_垃圾收集器详解

1、 前言 JVM就是Java虚拟机&#xff0c;说白了就是为了屏蔽底层操作系统的不一致而设计出来的一个虚拟机&#xff0c;让用户更加专注上层&#xff0c;而不用在乎下层的一个产品。这就是JVM的跨平台&#xff0c;一次编译&#xff0c;到处运行。 而JVM中的核心功能其实就是自动…
阅读更多...
Android音频框架总结

Android音频框架总结

1、AudioFlinger&#xff1a;接收多个APP的数据&#xff0c;合并下发&#xff1b;是策略的执行者&#xff0c;例如具体如何与音频设备通信&#xff0c;如何维护现有系统中的音频设备&#xff0c;以及多个音频流的混音如何处理等等都得由它来完 成。 AudioFlinger主要包含3个主…
阅读更多...
深度学习：自然语言处理

深度学习：自然语言处理

一、引言 自然语言处理作为人工智能领域的关键分支&#xff0c;致力于使计算机能够理解、分析和生成人类语言。近年来&#xff0c;随着深度学习技术的迅猛发展&#xff0c;自然语言处理取得了前所未有的突破&#xff0c;一系列创新技术和应用不断涌现&#xff0c;极大地推动了…
阅读更多...
网络安全-安全散列函数，信息摘要SHA-1，MD5原理

网络安全-安全散列函数，信息摘要SHA-1，MD5原理

安全散列函数 单向散列函数或者安全散列函数之所以重要&#xff0c;不仅在于消息认证(消息摘要。数据指纹)。还有数字签名&#xff08;加强版的消息认证&#xff09;和验证数据的完整性。常见的单向散列函数有MD5和SHA 散列函数的要求 散列函数的目的是文件、消息或者其它数据…
阅读更多...
java基础知识(常用类)

java基础知识(常用类)

目录 一、包装类（Wrapper) （1）包装类与基本数据的转换 （2）包装类与String类型的转换 （3）Integer类和Character类常用的方法 二、String类 （1）String类介绍 1)String 对象用于保存字符串，也就是一组字符序列 2)字符串常量对象是用双引号括起的字符序列。例如:&quo…
阅读更多...
音视频基础扫盲之认识PCM（Pulse Code Modulation，脉冲编码调制）

音视频基础扫盲之认识PCM（Pulse Code Modulation，脉冲编码调制）

PCM&#xff08;Pulse Code Modulation&#xff0c;脉冲编码调制&#xff09;一种用数字表示采样模拟信号的方法。是用于将波形表示的模拟音频信号转换为数字1和0表示的数字音频信号&#xff0c;而不压缩也不丢失信息的处理技术。PCM编码的最大的优点就是音质好&#xff0c;最大…
阅读更多...
【Zookeeper】四，Zookeeper节点类型、通知、仲裁、会话

【Zookeeper】四，Zookeeper节点类型、通知、仲裁、会话

文章目录 Zookeeper的架构znode的版本Zookeeper的节点类型层级树状结构znode的不同类型 Zookeeper监视与通知通知的类型 Zookeeper的仲裁Zk的会话会话的生命周期 Zookeeper的架构 Zookeeper的服务器端运行两种模式&#xff1a;独立模式&#xff08;standalone&#xff09;和仲…
阅读更多...
unity | 动画模块之卡片堆叠切换

unity | 动画模块之卡片堆叠切换

一、预览动画 可以放很多图&#xff0c;可以自己往后加&#xff0c;可以调图片x轴和y轴间距&#xff0c;可以调图片飞出方向&#xff0c;可以调堆叠方向。 图1 图片堆叠动画预览 二、纯净代码 有粉丝问我这个效果&#xff0c;最近很忙&#xff0c;没有时间细写&#xff0c;先…
阅读更多...
Python开发环境搭建+conda管理环境

Python开发环境搭建+conda管理环境

下载Miniconda 推荐从清华镜像下载安装包 Index of /anaconda/miniconda/ | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror 打开网页后&#xff0c;下拉到最后找到Miniconda3-latest前缀的文件&#xff0c;或者网页中直接搜索Miniconda3-latest&#xff0c;都可以找…
阅读更多...
Git——本地仓库链接并推送到多个远程仓库

Git——本地仓库链接并推送到多个远程仓库

步骤 1. 新建仓库init 或 删除已有仓库远程链接 // 1.新建init git init// 2.已有仓库&#xff0c;查看链接的远程仓库 git remote -v// 3.已有远程连接仓库&#xff0c;需要删除连接 git remote rm origin(或对应远程仓库名) 2.新建远程仓库 在gitee、github等托管平台创建…
阅读更多...
shell脚本基础学习_总结篇（完结）

shell脚本基础学习_总结篇（完结）

细致观看可以&#xff0c;访问shell脚本学习专栏&#xff0c;对应章节会有配图https://blog.csdn.net/2201_75446043/category_12833287.html?spm1001.2014.3001.5482 导语 一、shell脚本简介 1. 定义&#xff1a; 2. 主要特点&#xff1a; 3. shell脚本的基本结构 4. S…
阅读更多...
Ubuntu20.04+ROS 进行机械臂抓取仿真：环境搭建（一）

Ubuntu20.04+ROS 进行机械臂抓取仿真：环境搭建（一）

目录 一、从官网上下载UR机械臂 二、给UR机械臂添加夹爪 三、报错解决 本文详细介绍如何在Ubuntu20.04ROS环境中为Universal Robots的UR机械臂添加夹爪。首先从官方和第三方源下载必要的软件包&#xff0c;包括UR机械臂驱动、夹爪插件和相关依赖。然后&#xff0c;针对gazeb…
阅读更多...
23省赛区块链应用与维护（房屋租凭【下】）

23省赛区块链应用与维护（房屋租凭【下】）

23省赛区块链应用与维护（房屋租凭） 背景描述 随着异地务工人员的增多，房屋租赁成为一个广阔市场。目前，现有技术中的房屋租赁是由房主发布租赁信息，租赁信息发布在房屋中介或租赁软件，租客获取租赁信息后，现场看房，并签订纸质的房屋租赁合同，房屋租赁费用通过中介或…
阅读更多...
数字化转型的架构蓝图：从理论到实践的全面指导

数字化转型的架构蓝图：从理论到实践的全面指导

在数字经济的高速发展中&#xff0c;企业正面临全新的竞争压力。为了在数字化浪潮中保持竞争力&#xff0c;许多企业都在寻求一种系统化的方法来实现其数字化转型。这种变革不仅涉及技术创新&#xff0c;还包括业务流程的彻底重塑与组织文化的转型。要成功实现数字化转型&#…
阅读更多...
关于node全栈项目打包发布linux项目问题总集

关于node全栈项目打包发布linux项目问题总集

1.用pm2部署nest 说明&#xff1a;如果一开始将nest直接打包放到linux服务器上用pm2执行则会报错&#xff0c;这是因为tsconfig.build.tsbuildinfo文件的路径以及相关依赖问题。 报错会为&#xff1a;什么东西找不到.... 所以建议以下为步骤一步一步配置 将整个nest添加压缩包直…
阅读更多...
实验三 z变换及离散时间LTI系统的z域分析

实验三 z变换及离散时间LTI系统的z域分析

实验原理 有理函数z 变换的部分分式展开 【实例2-1】试用Matlab 命令对函数 X ( z ) 18 18 3 − 1 − 4 z − 2 − z − 3 X\left(z\right)\frac{18}{183^{-1} -4z^{-2} -z^{-3} } X(z)183−1−4z−2−z−318​ 进行部分分式展开&#xff0c;并求出其z 反变换。 B[18]; A…
阅读更多...
sed awk 第二版学习（十一）—— 交互式拼写检查器 spellcheck.awk

sed awk 第二版学习（十一）—— 交互式拼写检查器 spellcheck.awk

目录 1. 脚本代码 2. 执行情况 3. 代码详解 &#xff08;1&#xff09;BEGIN 过程 &#xff08;2&#xff09;主过程 &#xff08;3&#xff09;END 过程 &#xff08;4&#xff09;支持函数 4. 附加说明 这是一个基于 UNIX spell 程序的名为 spellcheck 的 awk 脚本&a…
阅读更多...
最新文章

Copyright @ 2022~2023