数据结构：链表进阶

ops/2024/11/25 9:25:39/

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

链表进阶

    • 1. ArrayList的缺陷
    • 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;

创建一个单链表：

    @Overridepublic 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;//将插入的第一个节点定义为头节点}

遍历这个单链表：

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

头插法：

  //头插法;时间复杂度：O(1)@Overridepublic 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)@Overridepublic 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;}@erridepublic 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是否在单链表当中：

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

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

@Overridepublic 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的节点：

 @Overridepublic 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;}}

得到单链表的长度：

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

清空链表：

 @Overridepublic 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的区别

在这里插入图片描述


http://www.ppmy.cn/ops/136527.html

相关文章

Python3 Flask 应用中使用阿里短信发送

Python3 Flask 应用中使用阿里短信发送

代码大部分都是官网提供的&#xff0c;稍做了一点修改。 需要申请 access_key_id 和 access_key_secret 很简单这里就不絮叨了&#xff0c;如果你不会私信我&#xff0c;我教你。 安装命令 pip install alibabacloud_dysmsapi201705253.1.0 # -*- coding: utf-8 -*- from…
阅读更多...
HARCT 2025 新增分论坛7：机器人和自动化的新趋势

HARCT 2025 新增分论坛7：机器人和自动化的新趋势

会议名称&#xff1a;机电液一体化与先进机器人控制技术国际会议 会议简称&#xff1a;HARCT 2025 大会时间&#xff1a;2025年1月3日-6日 大会地点&#xff1a;中国桂林 主办单位&#xff1a;桂林航天工业学院、广西大学、桂林电子科技大学、桂林理工大学 协办单位&#…
阅读更多...
网络爬虫——爬虫项目案例

网络爬虫——爬虫项目案例

本节将全面讲解如何通过实战爬虫项目解决复杂问题。结合最新技术和实际开发需求&#xff0c;案例将涵盖完整开发流程&#xff0c;包括需求分析、实现代码、优化方法和常见问题解决。力求实现高效、可扩展的爬虫项目架构&#xff0c;帮助开发者提升实战能力。 案例 1&#xff1a…
阅读更多...
局域网与广域网：探索网络的规模与奥秘（3/10）

局域网与广域网：探索网络的规模与奥秘（3/10）

一、局域网的特点 局域网覆盖有限的地理范围&#xff0c;通常在几公里以内&#xff0c;具有实现资源共享、服务共享、维护简单、组网开销低等特点&#xff0c;主要传输介质为双绞线&#xff0c;并使用少量的光纤。 局域网一般是方圆几千米以内的区域网络&#xff0c;其特点丰富…
阅读更多...
Python 使用 Token 认证方案连接 Kubernetes (k8s) 的详细过程

Python 使用 Token 认证方案连接 Kubernetes (k8s) 的详细过程

在 Kubernetes 中&#xff0c;使用 Token 认证是一种常见的客户端身份验证方式&#xff0c;尤其适用于 ServiceAccount。以下是详细的步骤&#xff0c;包括如何查看 Token、获取 API 服务地址、配置远程连接&#xff0c;以及如何在 Python 中连接 k8s。 1. 获取 Token 首先&a…
阅读更多...
MyBatis框架-动态SQL-XML中的常用标签+特殊字符在XML中的显示

MyBatis框架-动态SQL-XML中的常用标签+特殊字符在XML中的显示

一、if标签、where标签、trim标签、choose标签、set标签、foreach标签 1、问题引入&#xff1a;where关键字和and关键字在动态SQL里面应该如何添加&#xff1f; &#xff08;1&#xff09;if标签&#xff1a; test属性的值是判断条件 if标签里面的内容是条件成立时添加到SQ…
阅读更多...
Elasticsearch实战应用：构建高效搜索与分析平台

Elasticsearch实战应用：构建高效搜索与分析平台

Elasticsearch实战应用&#xff1a;构建高效搜索与分析平台 在当今大数据时代&#xff0c;数据的量级已经达到了惊人的级别&#xff0c;动辄上亿甚至更多。对于这样的数据量&#xff0c;如何进行有效的搜索和分析成为了众多开发者和数据科学家关注的焦点。Elasticsearch&#…
阅读更多...
SpringBoot多文件上传

SpringBoot多文件上传

多文件上传是在单文件上传的基础上修改而来&#xff0c;不了解单文件上传可以参考上一篇。以下在将修改部分展示如下&#xff1a; 一、修改upload.html文件&#xff1a; <!DOCTYPE html> <html> <head> <meta charset"UTF-8"> <title&g…
阅读更多...
最新文章

Copyright @ 2022~2023