链表---数据结构-黑马

链表

定义

链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上是不连续的。

分类

  • 单向链表，每个元素只知道自己的下一个元素是谁。
    在这里插入图片描述
  • 双向链表，每个元素知道自己的上一个元素和下一个元素。
    在这里插入图片描述
  • 循环链表，通常链表尾部节点 tail 指向的为null，而循环链表的tail指向链表的头部节点 head。
    在这里插入图片描述

链表中还有一种特殊的节点称之为，哨兵(Sentinel)节点，也称之为 哑元(Dummy)节点， 不存储数据，一般作为头尾，简化边界判断，如下如所示。
在这里插入图片描述

性能

随机访问

根据 i n d e x index index 查询，时间复杂度为 O ( n ) O(n) O(n) 。

插入或删除

  • 起始位置，时间复杂度为， O ( 1 ) O(1) O(1)
  • 结束位置，若已知尾部节点 tail ，时间复杂度为， O ( 1 ) O(1) O(1) ；否则为 O ( n ) O(n) O(n)
  • 中间位置，根据 index 查找的时间复杂度 + O ( 1 ) O(1) O(1)

单项链表实现

方法实现

节点类、头部添加、循环遍历、尾部添加

// 单项链表
public class SinglyLinkedList implements Iterable<Integer>() {private Node head = null;  // 头指针// 节点类private static class Node() {int value;  // 值Node node;  // 下一个节点public Node(int value, Node node) {this.value = value;this.node = node;}}@Overridepublic Iterator<Integer> iterator() {// 匿名内部类 -> 带名字的内部类return new NodeIterator();}// 1.链表头部添加元素public void addFirst(int value) {// 1.当链表为空时// head = new Node(value, null);  因为 head = new Node(value, head);这行代码可以处理链表为空的情况，则注释// 2.当链表非空时head = new Node(value, head);}// 寻找最后一个节点private Node findLast() {// 链表为空if (head == null) {return null;}Node p;for(p = head; p.next != null; p = p.next) {}return p;}// 3.尾部添加元素private void addLast(int value) {Node last = findLast();if (last == null) {// 头部添加addFirst(value);return;}last.next = new Node(value, null);}// 4.根据索引值查找结点public Node findNode(int index) {int i = 0;for(Node p = head; p != null; p = p.next, i++) {if (index == i) {return p;}}// 未找到return null;}// 5.根据index找到对应节点，并返回节点值public int get(int index) {Node p = findNode(index);if (p == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index))；}return p.value;}// 6.向索引位置插入元素public void insert(int index, int value) {if (index == 0) {  // 索引为0，向链表头部添加addFirst(value);return;}// 1.找到插入索引位置的上一个节点Node p = findNode(index - 1);// 判断p节点是否为空if (p == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node n = p.next;// p存在的情况p.next = new Node(value, n);}// 7.删除头部节点public void removeFirst() {if (head == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}// 头节点的下一个节点赋给头head = head.next;}// 8.按索引位置删除节点public void remove (int index) {if (index == 0) {removeFirst();return;}Node p = findNode(index - 1);  // 找到待删除节点的上一个节点if (p == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node n = p.next;               // 待删除节点if (n == null) {// 未找到待删除节点threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}p.next = n.next;			   // 待删除节点的上一个节点p的next指向待删除结点的下一个节点}// 6.遍历链表，方法1public void loop1(Consumer<Integer> consumer) {Node p = head; // 头节点赋给pwhile (p != null) {consumer.accept(p.value);p = p.next;}}// 循环遍历，方法2public void loop2(Consumer<Integer> consumer) {for(Node p = head; p != null; p = p.next) {consumer.accept(p.value);}}// 遍历，方法3，使用迭代器，实现接口Iterablepublic class NodeIterator implements Iterator<Integer> {Node p = head;@Overridepublic boolean hasNext() {  //判断是否有下一个元素return p != null;}@Overridepublic Integer next() {     //返回当前节点值int value = p.value;p = p.next;return value;      }}
}

测试

public class TestSinglyLinkedList() {// 尾部添加, 根据索引查找对应节点值测试@Testpublic void test3() {SinglyLinkedList list = new SinglyLinkedList();list.addLast(1);list.addLast(2);list.addLast(3);list.addLast(4);// Assertions.assertIterableEquals(List.of(1, 2, 3, 4), list);int i = list.get(2);System.out.println(i);  //i = 3}@Testpublic void test4() {SinglyLinkedList list = new SinglyLinkedList();list.addLast(1);list.addLast(2);list.addLast(3);list.addLast(4);list.insert(2, 5); 向索引为2的位置插入元素5for(Integer value : list) {System.out.print(value);}}
}

带哨兵的单向链表

// 单项链表
public class SinglyLinkedList implements Iterable<Integer>() {private Node head = new Node(666, null);  // 头指针// 节点类private static class Node() {int value;  // 值Node node;  // 下一个节点public Node(int value, Node node) {this.value = value;this.node = node;}}@Overridepublic Iterator<Integer> iterator() {// 匿名内部类 -> 带名字的内部类return new NodeIterator();}// 1.链表头部添加元素public void addFirst(int value) {insert(0, value);}// 寻找最后一个节点private Node findLast() {Node p;for(p = head; p.next != null; p = p.next) {}return p;}// 3.尾部添加元素private void addLast(int value) {Node last = findLast();last.next = new Node(value, null);}// 4.根据索引值查找结点public Node findNode(int index) {int i = -1;for(Node p = head; p != null; p = p.next, i++) {if (index == i) {return p;}}// 未找到return null;}// 5.根据index找到对应节点，并返回节点值public int get(int index) {Node p = findNode(index);if (p == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}return p.value;}// 6.向索引位置插入元素public void insert(int index, int value) {// 1.找到插入索引位置的上一个节点Node p = findNode(index - 1);// 判断p节点是否为空if (p == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node n = p.next;// p存在的情况p.next = new Node(value, n);}// 7.删除头部节点public void removeFirst() {remove(0);}// 8.按索引位置删除节点public void remove (int index) {Node p = findNode(index - 1);  // 找到待删除节点的上一个节点if (p == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node n = p.next;               // 待删除节点if (n == null) {// 未找到待删除节点threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}p.next = n.next;			   // 待删除节点的上一个节点p的next指向待删除结点的下一个节点}// 6.遍历链表，方法1public void loop1(Consumer<Integer> consumer) {Node p = head.next; // 头节点赋给pwhile (p != null) {consumer.accept(p.value);p = p.next;}}// 循环遍历，方法2public void loop2(Consumer<Integer> consumer) {for(Node p = head.next; p != null; p = p.next) {consumer.accept(p.value);}}// 遍历，方法3，使用迭代器，实现接口Iterablepublic class NodeIterator implements Iterator<Integer> {Node p = head.next;@Overridepublic boolean hasNext() {  //判断是否有下一个元素return p != null;}@Overridepublic Integer next() {     //返回当前节点值int value = p.value;p = p.next;return value;      }}
}

双向链表–哨兵

public class DoublyLinkedListSentinel implements Iterator<Integer> {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 head; //头哨兵节点private Node tail; //尾哨兵节点public DoublyLinkedListSentinel () {head = new Node(null, 666, null);tail = new Node(null, 888, null);head.next = tail;tail.prev = head;}// 根据索引位置找节点private Node findIndex(int index) {int i = -1;for(Node p = head; p != tail; p = p.next, i++) {if (index == i) {return p;}    }return null;}// 头部插入元素public void addFirst(int value) {insert(0, value);} // 1.对应索引位置插入元素public void insert(int index, int value) {Node prev = findIndex(index - 1);		// 插入索引位置前一个结点if (prev == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node next = prev.next;					// 成为待插入元素节点的下一个节点Node node = new Node(prev, value, next); prev.next = node;next.prev = node;}// 尾部添加元素public void addLast(int value) {Node last = tail.prev;Node added = new Node(last, value, tail);last.next = added;tail.prev = added; }// 删除最后一个节点public void removeLast() {Node removed = tail.prev;if (removed == head) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node prev = removed.prev;prev.next = tail;tail.prev = prev;}// 删除头节点public void removeFirst() {remove(0);}// 删除节点public void remove(int index) {Node prev = findIndex(index - 1);		// 删除索引位置前一个结点if (prev == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node next = prev.next.next;					// 待删除元素节点的下一个节点if (next == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}prev.next = next;next.prev = prev;}// 迭代器遍历@Overridepublic Iterator<Integer> iterator() {return new Iterator<Integer>() {Node p = head.next;@Overridepublic boolean hasNext() {return p != tail;}@Override public Integer next() {int value = p.value;p = p.next;return value;}}}}

环形链表

双向环形链表带哨兵，哨兵既作为头哨兵，又作为尾哨兵
在这里插入图片描述

public class DoublyLinkedListSentinel {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 DoublyLinkedListSentinel () {sentinel.prev = sentinel;sentinel.next = sentinel;}// 根据索引位置找节点private Node findIndex(int index) {int i = -1;for(Node p = sentinel; p != sentinel; p = p.next, i++) {if (index == i) {return p;}    }return null;}// 头部插入元素public void addFirst(int value) {Node a = sentinel;Node b = sentinel.next;Node added = new Node(a, value, b);a.next = added;b.prev = added;} // 1.对应索引位置插入元素public void insert(int index, int value) {Node prev = findIndex(index - 1);		// 插入索引位置前一个结点if (prev == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node next = prev.next;					// 成为待插入元素节点的下一个节点Node node = new Node(prev, value, next); prev.next = node;next.prev = node;}// 尾部添加元素public void addLast(int value) {Node b = sentinel;Node a = sentinel.prev;Node added = new Node(a, value, b);b.prev = added;a.next = added;}// 删除头节点public void removeFirst() {Node removed = sentinel.next;if (removed == sentinel) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node a = sentinel;Node b = removed.next;a.next = b;b.prev = a;}// 删除最后一个节点public void removeLast() {Node removed = sentinel.prev;if (removed == sentinel) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node a = sentinel;Node b = removed.prev;a.prev = b;b.next = a;}// 根据节点值查找该节点public Node findByValue(int value) {Node p = sentinel.next;whlie (p != sentinel) {if (p.value == value) {return p;}p = p.next;}return null;}// 根据节点值删除节点public void remove(int vlaue) {Node removed = findByValue(value);if (removed == null) {// 节点为空，抛出异常threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));}Node a = removed.prev;Node b = removed.next;a.next = b;b.prev = a;}// 迭代器遍历@Overridepublic Iterator<Integer> iterator() {return new Iterator<Integer>() {Node p = sentinel.next;@Overridepublic boolean hasNext() {return p != sentinel;}@Override public Integer next() {int value = p.value;p = p.next;return value;}}}
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

10W数据导入该如何与库中数据去重？

10W数据导入该如何与库中数据去重？

使用的是PostgreSQL 在做大数据量&#xff08;十万级&#xff09;导入时&#xff0c;某些字段和数据库表里数据&#xff08;千万级&#xff09;重复的需要排除掉&#xff0c;把表数据查询出来用程序的方式判断去重效率很低&#xff0c;于是考虑用临时表。 先把新数据插入到临时…
阅读更多...
Git工具练习网站

Git工具练习网站

Learn Git Branching
阅读更多...
【深度学习】单层神经网络

【深度学习】单层神经网络

单层神经网络 神经元感知机 1943年&#xff0c;心理学家McCulloch和数学家Pitts共同发表了神经网络的开山之作A Logical Calculus of the Ideas Immanent in Nervours Activity1&#xff0c;提出了神经网络的第一个数学模型——MP模型。该模型也成为了人工神经网络的基础。 神经…
阅读更多...
AXI DMA IP的MICRO DMA模式和去掉SG（Scatter-Gather）功能的模式

AXI DMA IP的MICRO DMA模式和去掉SG（Scatter-Gather）功能的模式

AXI DMA IP的MICRO DMA模式和去掉SG&#xff08;Scatter-Gather&#xff09;功能的模式确实有一些区别。让我们详细比较这两种模式&#xff1a; 功能复杂度&#xff1a; MICRO DMA模式&#xff1a;设计为更简单、更轻量级的DMA解决方案。无SG模式&#xff1a;仍保留了基本DMA的…
阅读更多...
Error hdl vendor backen is missing

Error hdl vendor backen is missing

跑vcs时报这个错&#xff0c; // hdl vendor backends are defined for VCS,QUESTA,INCA #if defined(VCS) || defined(VCSMX) #include "uvm_hdl_vcs.c" #else #ifdef QUESTA #include "uvm_hdl_questa.c" #else #if defined(INCA) || defined(NCSC) #in…
阅读更多...
leetcode-448. 找到所有数组中消失的数字

leetcode-448. 找到所有数组中消失的数字

题目描述 给你一个含 n 个整数的数组 nums &#xff0c;其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字&#xff0c;并以数组的形式返回结果。 示例 1&#xff1a; 输入&#xff1a;nums [4,3,2,7,8,2,3,1] 输出&#xff1a;[5,6…
阅读更多...
代码随想录算法训练营第十四天| 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度

代码随想录算法训练营第十四天| 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度

目录 一、LeetCode 226.翻转二叉树思路&#xff1a;C代码 二、LeetCode 101. 对称二叉树思路C代码 二、LeetCode 104.二叉树的最大深度思路C代码 二、LeetCode 111.二叉树的最小深度思路C代码 总结 一、LeetCode 226.翻转二叉树 题目链接&#xff1a;LeetCode 226.翻转二叉树 …
阅读更多...
Redis缓存配置

Redis缓存配置

redis缓存 使用redis缓存的原因是因为在可能的高并发环境下&#xff0c;mysql数据库无法承受大量的请求&#xff0c;可能会导致数据库崩溃。而这些请求很大一部分都是查询请求&#xff0c;因此采用redis这样的以内存作为存储数据空间的数据库来存储查询请求的数据&#xff0c;…
阅读更多...
springboot静态资源访问问题归纳

springboot静态资源访问问题归纳

以下内容基于springboot 2.3.4.RELEASE 1、默认配置的springboot项目&#xff0c;有四个静态资源文件夹&#xff0c;它们是有优先级的&#xff0c;如下&#xff1a; "classpath:/META-INF/resources/", &#xff08;优先级最高&#xff09; "classpath:/reso…
阅读更多...
【Android】android，震动一下，50ms，震动等级设置低一点

【Android】android，震动一下，50ms，震动等级设置低一点

要在Android中实现震动50ms，并将震动等级设置为低，你可以使用Vibrator类。下面是一个简单的代码示例，展示如何实现这个功能： import android.content.Context; import android.os.VibrationEffect; import android.os.Vibrator
阅读更多...
React+Vis.js（03）：设置节点形状

React+Vis.js（03）：设置节点形状

文章目录 Vis支持的形状类型代码实现完整代码实现效果Vis支持的形状类型 circle（圆形）box（盒子）dot（点）star（五角星）triangle（三角形）ellipse（椭圆形）triangleDown（倒三角形）diamond（菱形）代码实现 通过shape属性来定义每个节点的形状 const nodes = new vis…
阅读更多...
Unified 阻抗控制 architecture、framework、approach

Unified 阻抗控制 architecture、framework、approach

Unified 阻抗控制&#xff08;Unified Impedance Control&#xff09;作为一种控制策略&#xff0c;其architecture&#xff08;架构&#xff09;、framework&#xff08;框架&#xff09;和approach&#xff08;方法&#xff09;为&#xff1a; 一、Unified 阻抗控制 Archite…
阅读更多...
骨板和螺钉市场分析：前五大厂商占有大约78.0%的市场份额

骨板和螺钉市场分析：前五大厂商占有大约78.0%的市场份额

据QYResearch调研团队最新报告“全球骨板和螺钉市场报告2024-2030”显示&#xff0c;预计2030年全球骨板和螺钉市场规模将达到76.2亿美元&#xff0c;未来几年年复合增长率CAGR为3.7%。 根据QYResearch头部企业研究中心调研&#xff0c;全球范围内骨板和螺钉生产商主要包括J &a…
阅读更多...
视频美颜SDK与直播美颜工具的开发详解与技术优化

视频美颜SDK与直播美颜工具的开发详解与技术优化

本篇文章&#xff0c;小编将为开发者提供一份详细的美颜指南。 一、视频美颜SDK的核心功能 视频美颜SDK是一种嵌入式软件开发工具包&#xff0c;允许开发者在应用中轻松实现实时美颜效果。其核心功能主要包括&#xff1a; 1.实时磨皮 2.美白功能 3.瘦脸与大眼 4.智能滤镜…
阅读更多...
AWS 消息队列服务 SQS

AWS 消息队列服务 SQS

AWS 消息队列服务 SQS 引言什么是 SQSSQS 访问策略 Access Policy示例&#xff1a;如何为 DataLake Subscription 配置 SQS 引言 应用系统需要处理海量数据&#xff0c;数据发送方和数据消费方是通过什么方式来无缝集成消费数据的&#xff0c;AWS 提供 SQS 消息队列服务来解决…
阅读更多...
设计模式21-组合模式

设计模式21-组合模式

设计模式21-组合模式&#xff08;Composite Pattern&#xff09; 写在前面 动机定义与结构定义结构主要类及其关系 C代码推导优缺点应用场景总结补充叶子节点不重载这三个方法叶子节点重载这三个方法结论 写在前面 数据结构模式 常常有一些组件在内部具有特定的数据结构。如何…
阅读更多...
相机光学（三十四）——色差仪颜色观察者视角

相机光学（三十四）——色差仪颜色观察者视角

1.为什么会有观察者视角 颜色观察角度主要涉及到人眼观察物体时&#xff0c;‌视角的大小以及屏幕显示颜色的方向性对颜色感知的影响。‌ 人眼观察物体的视角&#xff1a;‌在黑暗条件下&#xff0c;‌人眼主要依靠杆体细胞来分辨物体的轮廓&#xff0c;‌而杆体细胞分布在视网…
阅读更多...
牛客网SQL进阶135 ：每个6/7级用户活跃情况

牛客网SQL进阶135 ：每个6/7级用户活跃情况

每个67级用户活跃情况_牛客题霸_牛客网 0 问题描述 基于用户信息表user_info、、试卷作答记录表exam_record、题目练习记录表practice_record&#xff0c;统计 每个6/7级用户总活跃月份数、2021年活跃天数、2021年试卷作答活跃天数、2021年答题活跃天数&#xff0c;结果 按照总…
阅读更多...
在linux上架设Web服务器Apache（Ubuntu）

在linux上架设Web服务器Apache（Ubuntu）

欢迎诸位来阅读在下的博文~ 在这里&#xff0c;在下会不定期发表一些浅薄的知识和经验&#xff0c;望诸位能与在下多多交流&#xff0c;共同努力! 江山如画&#xff0c;客心如若&#xff0c;欢迎到访&#xff0c;一展风采 文章目录 背景1. 安装 Apache2. 启动和检查 Apache 服务…
阅读更多...
常用的分类算法及其优缺点

常用的分类算法及其优缺点

常用的分类算法包括决策树、朴素贝叶斯、支持向量机&#xff08;SVM&#xff09;、K-近邻&#xff08;KNN&#xff09;、逻辑回归以及神经网络等。每种算法都有其独特的优点和缺点&#xff0c;适用于不同的场景和需求。以下是这些常用分类算法的优缺点概述&#xff1a; 1. 决策…
阅读更多...
最新文章

Copyright @ 2022~2023