TypeScript_队列结构-链表

news2024/9/24 7:21:31

队列

队列（Queue），它是一种受限的线性表，先进先出（FIFO First In First Out）

  • 受限之处在于它只允许在队列的前端（front）进行删除操作
  • 而在队列的后端（rear）进行插入操作

队列

  • 有五份文档需要打印，这些文档会按照次序放入到打印队列中
  • 打印机会依次从队列中取出文档，优先放入的文档，优先被取出，并且对该文档进行打印
  • 以此类推，直到队列中不再有新的文档

线程队列:

  • 在开发中，为了让任务可以并行处理，通常会开启多个线程
  • 但是，我们不能让大量的线程同时运行处理任务。（占用过多的资源）
  • 这个时候，如果有需要开启线程处理任务的情况，我们就会使用线程队列
  • 线程队列会依照次序来启动线程，并且处理对应的任务

当然队列还有很多其他应用，我们后续的很多算法中也会用到队列（比如二叉树的层序遍历）

队列操作

  • enqueue(element)：向队列尾部添加一个（或多个）新的项
  • dequeue()：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素
  • front/peek()：返回队列中第一个元素————最先被添加，也将是最先被移除的元素。队列不做任何变动 （不移除元素，只返回元素信息一一与 Stack 类的 peek 方法非常类似）
  • isEmpty()：如果队列中不包含任何元素，返回 true，否则返回 false
  • size()：返回队列包含的元素个数，与数组的 length 属性类似

实现队列

队列的实现和栈一样，有两种方案：

  • 基于 数组 实现
  • 基于 链表 实现
import IQueue from './IQueue'

class ArrayQueue<T> implements IQueue<T> {
  // 内部是通过数组保存
  private data: T[] = []
  enqueue(element: T): void {
    this.data.push(element)
  }
  dequeue(): T | undefined {
    return this.data.shift()
  }
  peek(): T | undefined {
    return this.data[0]
  }
  isEmpty(): boolean {
    return this.data.length === 0
  }
  size(): number {
    return this.data.length
  }
}

export default ArrayQueue

泛型

interface IList<T> {
  peek(): T | undefined
  isEmpty(): boolean
  size(): number
}
interface IQueue<T> extends IList<T> {
  enqueue(element: T): void
  dequeue(): T | undefined
}

击鼓传花

原游戏规则

  • 班级中玩一个游戏，所有学生围成一圈，从某位同学手里开始向旁边的同学传一束花
  • 这个时候某个人（比如班长），在击鼓，鼓声停下的一颗，花落在谁手里，谁就出来表演节目

修改游戏规则

  • 我们来修改一下这个游戏规则
  • 几个朋友一起玩一个游戏，围成一圈，开始数数，数到某个数字的人自动淘汰
  • 最后剩下的这个人会获得胜利，请问最后剩下的是原来在哪一个位置上的人

封装一个基于队列的函数

  • 参数：所有参与人的姓名，基于的数字口结果：最终剩下的一人的姓名
function hotPotato(names: string[], num: number) {
  if (names.length === 0) return -1
  // 1.创建队列结构
  const queue = new ArrayQueue<string>()
  // 2.将所有的name入队操作
  for (const name of names) {
    queue.enqueue(name)
  }
  // 3.淘汰规则
  while (queue.size() > 1) {
    for (let i = 1; i < num; i++) {
      const name = queue.dequeue()
      if (name) queue.enqueue(name)
    }
    queue.dequeue()
  }
  return queue.dequeue()
}

约瑟夫环问题

阿桥问题（有时也称为约瑟夫斯置换），是一个出现在计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环

  • 人们站在一个等待被处决的圈子里
  • 计数从圆圈中的指定点开始，并沿指定方向围绕圆圈进行
  • 在跳过指定数量的人之后，处刑下一个人
  • 对剩下的人重复该过程，从下一个人开始，朝同一方向跳过相同数量的人，直到只剩下一个人，并被释放
  • 在给定数量的情况下，站在第几个位置可以避免被处决?

这个问题是以弗拉维奥·约瑟夫命名的，他是1世纪的一名犹太历史学家口

  • 他在自己的日记中写道，他和他的40个战友被罗马军队包围在洞中
  • 他们讨论是自杀还是被俘，最终决定自杀，并以抽签的方式决定谁杀掉谁

剑指 Offer 62. 圆圈中最后剩下的数字

0,1,···,n-1 这 n 个数字排成一个圆圈，从数字 0 开始，每次从这个圆圈里删除第 m 个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字

例如，0、1、2、3、4 这 5 个数字组成一个圆圈，从数字 0 开始每次删除第 3 个数字，则删除的前 4 个数字依次是 2、0、4、1，因此最后剩下的数字是 3

import ArrayQueue from './queue'

function lastRemaining(n: number, m: number) {
  // 1.创建队列
  const queue = new ArrayQueue<number>()
  // 2.将所有的数字加入队列中
  for (let i = 0; i < n; i++) {
    queue.enqueue(i)
  }
  // 3.判断队列中是否还有数字
  while (queue.size() > 1) {
    for (let i = 1; i < m; i++) {
      queue.enqueue(queue.dequeue()!)
    }
    queue.dequeue()
  }
  return queue.dequeue()
}

console.log(lastRemaining(5, 3)) // 3
console.log(lastRemaining(10, 17)) // 2

动态规划

function lastRemaining(n: number, m: number) {
  let position = 0
  for (let i = 2; i <= n; i++) {
    position = (position + m) % i
  }
  return position
}

链表

链表与数组

链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同

数组有很多缺点:

  • 数组的创建通常需要申请一段 连续的内存空间（一整块的内存），并且大小是固定的（大多数编程语言数组都是固定的），所以当当前数组 不能满足容量需求 时，需要 扩容。(一般情况下是申请一个更大的数组，比如 2 倍。然后将原数组中的元素复制过去)
  • 而且在 数组开头或中间位置插入数据的成本很高，需要 进行大量元素的位移
  • 尽管 JavaScript 的 Array 底层可以帮我们做这些事，但背后的原理依然是这样

要存储多个元素，另外一个选择就是链表

  • 但不同于数组，链表中的元素在内存中不必是连续的空间
  • 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有些语言称为指针或者链接）组成

相对于数组，链表有一些优点:

  • 内存空间不是必须连续的
    • 可以充分利用计算机的内存，实现灵活的内存动态管理口
  • 链表不必在创建时就 确定大小，并且大小可以 无限的延伸 下去口
  • 链表在 插入和删除 数据时，时间复杂度 可以达到 O(1)
    • 相对数组效率高很多

相对于数组，链表有一些缺点:

  • 链表访问任何一个位置的元素时，都需要 从头开始访问。(无法跳过第一个元素访问任何一个元素)
  • 无法通过下标直接访问元素，需要从头一个个访问，直到找到对应的元素

链表

什么是链表呢?

  • 其实上面我们已经简单的提过了链表的结构，我们这里更加详细的分析一下
  • 链表类似于火车：有一个火车头，火车头会连接一个节点，节点上有乘客（类似于数据），并且这个节点会连接下一个节点，以此类推

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

实现链表

  • 封装一个 Node 类，用于封装每一个节点上的信息 (包括值和指向下一个节点的引用)，它是一个泛型类
  • 封装一个 LinkedList 类，用于表示我们的链表结构。(和 Java 中的链表同名，不同 Java 中的这个类是一个双向链表)
  • 链表中我们保存两个属性，一个是链表的长度，一个是链表中第一个节点
class Node<T> {
  value: T
  next: Node<T> | null = null
  constructor(value: T) {
    this.value = value
  }
}

class LinkedList<T> {
  private head: Node<T> | null = null
  private size: number = 0
  get length() {
    return this.size
  }
}

链表操作

  • append(element)：向链表尾部添加一个新的项
  • insert(position，element)：向链表的特定位置插入一个新的项
  • get(position)：获取对应位置的元素indexOf(element): 返回元素在链表中的索引。如果链表中没有该元素则返回 -1
  • update(position，element)：修改某个位置的元素
  • removeAt(position)：从链表的特定位置移除一项
  • remove(element)：从链表中移除一项
  • isEmpty()：如果链表中不包含任何元素，返回 true，如果链表长度大于 0 则返回 false
  • size()：返回链表包含的元素个数。与数组的 length 属性类似

向链表尾部追加数据可能有两种情况

  • 链表本身为空，新添加的数据时唯一的节点
  • 链表不为空，需要向其他节点后面追加节点
class Node<T> {
  value: T
  next: Node<T> | null = null
  constructor(value: T) {
    this.value = value
  }
}

class LinkedList<T> {
  private head: Node<T> | null = null
  private size: number = 0
  get length() {
    return this.size
  }
  // 根据position获取到当前的节点（不是节点的value，而是获取节点）
  private getNode(position: number): Node<T> | null {
    let index = 0
    let current = this.head
    while (index++ < position && current) {
      current = current.next
    }
    return current
  }

  append(value: T) {
    // 1.根据value创建一个新及诶单
    const newNode = new Node(value)
    // 2.判断this.heade是否为null
    if (!this.head) {
      this.head = newNode
    } else {
      let current = this.head
      while (current.next) {
        current = current.next
      }
      current.next = newNode
    }
    this.size++
  }

  traverse() {
    const values: T[] = []
    let current = this.head
    while (current) {
      values.push(current.value)
      current = current.next
    }
    console.log(values.join('->'))
  }

  insert(value: T, position: number): boolean {
    // 1.越界的判断
    if (position < 0 || position > this.size) return false
    // 2.根据value创建新的节点
    const newNode = new Node(value)
    // 3.判断是否需要插入头部
    if (position === 0) {
      // 新节点next指向头部节点、头部
      newNode.next = this.head
      this.head = newNode
    } else {
      const previous = this.getNode(position - 1)
      newNode.next = previous?.next ?? null
      previous!.next = newNode
    }
    this.size++
    return true
  }

  removeAt(position: number): T | null {
    // 1.越界的判断
    if (position < 0 || position >= this.size) return null
    // 2.判断是否是删除第一个节点
    let current = this.head
    if (position === 0) {
      this.head = current?.next ?? null
    } else {
      const previous = this.getNode(position - 1)
      previous!.next = previous?.next?.next ?? null
    }
    this.size--
    return current?.value ?? null
  }

  get(position: number): T | null {
    // 1.越界的判断
    if (position < 0 || position >= this.size) return null
    // 2.查找元素，并且返回元素
    return this.getNode(position)?.value ?? null
  }

  update(value: T, position: number): boolean {
    if (position < 0 || position >= this.size) return false
    const currentNode = this.getNode(position)
    // 获取对应位置的节点，直接更新即可
    currentNode!.value = value
    return true
  }

  indexOf(value: T): number {
    let current = this.head
    let index = 0
    while (current) {
      if (current.value === value) {
        return index
      }
      current = current.next
      index++
    }
    return -1
  }

  remove(value: T): T | null {
    const index = this.indexOf(value)
    return this.removeAt(index)
  }

  isEmpty() {
    return this.size === 0
  }
}

设计链表

707. 设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点

抽离接口方法

interface IList<T> {
  peek(): T | undefined
  isEmpty(): boolean
  size(): number
}

interface ILinkedList<T> extends IList<T> {
  append(value: T): void
  traverse(): void
  insert(value: T, position: number): boolean
  get(position: number): T | null
  update(value: T, position: number): boolean
  indexOf(value: T): number
  remove(value: T): T | null
}

删除链表中的节点

237. 删除链表中的节点

有一个单链表的 head，我们想删除它其中的一个节点 node

给你一个需要删除的节点 node 。你将 无法访问 第一个节点 head

链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

  • 给定节点的值不应该存在于链表中
  • 链表中的节点数应该减少 1
  • node 前面的所有值顺序相同
  • node 后面的所有值顺序相同
class ListNode {
  val: number
  next: ListNode | null
  constructor(val?: number, next?: ListNode | null) {
    this.val = val === undefined ? 0 : val
    this.next = next === undefined ? null : next
  }
}

function deleteNode(node: ListNode | null): void {
  node!.val = node!.next!.val
  node!.next = node!.next!.next
}

反转链表

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表

利用栈结构解决

function reverseList(head: ListNode | null): ListNode | null {
  if (head === null) return null
  if (head.next === null) return head
  const stack: ListNode[] = []
  let current: ListNode | null = head
  while (current) {
    stack.push(current)
    current = current.next
  }
  let newHead: ListNode = stack.pop()!
  let newHeadCurrent = newHead
  while (stack.length) {
    const node = stack.pop()!
    newHeadCurrent.next = node
    newHeadCurrent = newHeadCurrent.next
  }
  // 注意：获取到最后一个节点时，一定要将节点的 next 置为 null
  newHeadCurrent.next = null
  return newHead
}

const node1 = new ListNode(1)
node1.next = new ListNode(2)
node1.next.next = new ListNode(3)
const newHead = reverseList(node1)
let current = newHead
while (current) {
  console.log(current.val)
  current = current.next
}

非递归方式

  1. 让 current 指向下一个节点

    • 目的：保留着下一个节点的引用，可以拿到，并且不会销毁

  2. 改变 head 当前指向的节点，指向 newHead

    • 对于第一个节点来说，指向 newHead 就是指向 null

  3. 让 newHead 指向 head 节点

    • 目的是下一次遍历时，第二步操作，可以让下一个节点指向第一个节点

  4. 让 head 移向下一个节点，指向 current

function reverseList(head: ListNode | null): ListNode | null {
  if (head === null || head.next === null) return head
  let newHead: ListNode | null = null
  while (head) {
    let current: ListNode | null = head.next
    head.next = newHead
    newHead = head
    head = current
  }
  return newHead
}

在这里插入图片描述

递归方式

  • 第一次进入 const newHead 下面的代码是倒数第二个节点，因为倒数第一个节点的 next 为 null
function reverseList(head: ListNode | null): ListNode | null {
  if (head === null || head.next === null) return head
  const newHead = reverseList(head.next)
  head.next.next = head
  head.next = null
  return newHead
}

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

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

相关文章

python后端，一个账户，多设备登录管理

python后端，一个账户，多设备登录管理

一个账号&#xff0c;多台设备同时登陆的问题&#xff0c;设计以及实现 参考这篇文章&#xff1a; https://www.alibabacloud.com/help/zh/tair/use-cases/manage-multi-device-logon-from-a-single-user-by-using-tairhash1.0 设计思路 利用的是Redis&#xff0c;主设备的保…
阅读更多...
Webgoat-Hijack a session通关答题教程

Webgoat-Hijack a session通关答题教程

Webgoat-Hijack a session Hijack session是会话劫持&#xff0c;先了解需要用到的知识&#xff1a; Cookie原理&#xff1a; 1.客户端向服务端发起请求 2.服务端返回cookie&#xff0c;自己也保存了一份 3.客户端收到后&#xff0c;将cookie也保存起来 4.客户端再次发起请求时…
阅读更多...
某物联网数智化园区行业基于 KubeSphere 的云原生实践

某物联网数智化园区行业基于 KubeSphere 的云原生实践

公司简介 作为物联网 数智化园区一体化解决方案提供商&#xff0c;我们致力于为大中型园区、停车场提供软硬件平台&#xff0c;帮助园区运营者实现数字化、智能化运营。 在使用 K8s 之前我们使用传统的方式部署上线&#xff0c;使用 spug&#xff08;一款轻量级无 Agent 的自…
阅读更多...
算术化电路中如何使用定制gates？

算术化电路中如何使用定制gates？

1. 引言 现有ZKP证明系统中&#xff0c;除关注proof size和verification time之外&#xff0c;Prover Time是一个重要瓶颈。 当侧重Prover Time时&#xff0c;可考虑STARK方案。并借助recursive STARKSNARK&#xff0c;来获得small proof。 Prover Time&#xff1a; 直接取…
阅读更多...
【VM】保姆级VM算法平台二次开发之-环境配置

【VM】保姆级VM算法平台二次开发之-环境配置

VM算法平台二次开发 1.下载Visual Studio 20222.项目的创建 C# 应用3.设置属性&#xff0c;去掉属选型32位4. 进行引用的导入工作5. 重新加载&#xff0c;查看引用6. 工具箱添加Dll的依赖。&#xff08;只需要加载一次就行&#xff09; 1.下载Visual Studio 2022 可以直接在官…
阅读更多...
PyTorch深度学习遥感影像地物分类与目标检测、分割及遥感影像问题深度学习优化实践技术应用

PyTorch深度学习遥感影像地物分类与目标检测、分割及遥感影像问题深度学习优化实践技术应用

我国高分辨率对地观测系统重大专项已全面启动&#xff0c;高空间、高光谱、高时间分辨率和宽地面覆盖于一体的全球天空地一体化立体对地观测网逐步形成&#xff0c;将成为保障国家安全的基础性和战略性资源。未来10年全球每天获取的观测数据将超过10PB&#xff0c;遥感大数据时…
阅读更多...
未来芯片设计领域的药明康德——青芯如何在N个项目间游走平衡

未来芯片设计领域的药明康德——青芯如何在N个项目间游走平衡

总部位于上海张江的青芯半导体&#xff08;CyanSemi&#xff09;&#xff0c;ASIC定制设计是其核心业务之一。 青芯在单纯的设计服务维度之上&#xff0c;打造了从设计到生产的一套完整ASIC定制业务&#xff0c;不仅做芯片设计&#xff0c;还提供封装、测试服务&#xff0c;也…
阅读更多...
ikuai配置内外网及动态域名，外部可以直接通过域名进行访问私网的网络服务环境。

ikuai配置内外网及动态域名，外部可以直接通过域名进行访问私网的网络服务环境。

1.安装ikuai虚拟机&#xff0c;这里可以自行百度&#xff0c;网上一堆教程用vm安装ikuai 2.重要的&#xff0c;配置网卡&#xff0c; 先上图在说。下图是虚拟机配置了两个网卡&#xff0c; 第一个网卡vmnet0配置为自动桥接模式。 第二个网卡vmnat1配置为NAT模式。 配置前需要…
阅读更多...
C语言递归写n的k次方

C语言递归写n的k次方

int Func(int n,int k) {if (k 0){return 1;}else if (k > 1){return n * Func(n, k - 1);;}}int main() {int i 0;int j 0;printf("请输入数n和他的k次方\n");scanf("%d %d", &i,&j);int r Func(i,j);printf("%d的%d次方 %d\n"…
阅读更多...
气传导耳机排名，四款市面上热销相当不错的气传导耳机推荐

气传导耳机排名，四款市面上热销相当不错的气传导耳机推荐

​在当今快速的生活节奏中&#xff0c;气传导耳机成为了越来越多人的选择。它们以出色的音质和舒适度而广受好评。在本文中&#xff0c;我们将为您推荐四款市面上热销相当不错的气传导耳机&#xff0c;帮助你找到最适合自己的耳机。 推荐一&#xff1a;NANK南卡00压开放式耳机…
阅读更多...
spring cloud seata集成

spring cloud seata集成

目录 一、seata使用场景 二、seata组成 三、seata服务端搭建 四、客户端使用seata 4.1 客户端增加undo_log表 4.2 客户端增加seata相关配置 4.3 客户端使用注解 五、测试 一、seata使用场景 微服务中&#xff0c;一个业务涉及到多个微服务系统&#xff0c;每个微服务…
阅读更多...
elementUI中的table动态表单记录

elementUI中的table动态表单记录

form表单与table一起使用 之前一直以为form表单是单独使用&#xff0c;现在联动起来发现只是套了一层外壳&#xff0c;并不是很麻烦的事情 form的单独使用 <el-form :model"ruleForm" status-icon :rules"rules" ref"ruleForm" label-widt…
阅读更多...
前端进阶之——模块化

前端进阶之——模块化

在做项目的时候越来越发现模块化的重要性&#xff0c;做好模块化开发不仅给后期的维护带来不少好处而且大大提升项目开发效率&#xff0c;接下来整理一下模块化相关知识吧。 模块化开发的优点 封装方法、提高代码的复用性、可维护性和可读性隔离作用域&#xff0c;避免污染全…
阅读更多...
【SpringSecurity】十、JWT工具类

【SpringSecurity】十、JWT工具类

文章目录 1、jwt类库与相关依赖2、工具类3、总结 1、jwt类库与相关依赖 <!-- 添加jwt的依赖 --> <dependency><groupId>com.auth0</groupId><artifactId>java-jwt</artifactId><version>3.11.0</version> </dependency>…
阅读更多...
如何看待中小企业实现数字化转型难的问题？有哪些工具可以降低企业数字化的门槛？

如何看待中小企业实现数字化转型难的问题？有哪些工具可以降低企业数字化的门槛？

中小企业 (SME) 数字化转型的难度可能存在很大差异&#xff0c;具体取决于行业、现有技术基础设施、领导层的数字素养、预算限制以及变革的整体准备程度等因素。但总体而言&#xff0c;中小企业在进行数字化转型时往往面临以下几个挑战&#xff1a; 1.资源有限&#xff1a;与大…
阅读更多...
Openlayer系列：利用GeoServer和Openlayer地图显示区域掩模

Openlayer系列：利用GeoServer和Openlayer地图显示区域掩模

前言 利用GeoServer和Openlayer地图显示区域掩模 利用GeoServer进行图层发布 Openlayer地图显示区域掩模 对界面地图进行切换&#xff0c;卫星图利用GeoServer&#xff0c;水系等根据geojson文件生成图层&#xff0c;效果如下 卫星图部分代码如下&#xff1a; // 创建卫星图…
阅读更多...
淘宝API接口，可以运用到多种业务场景中

淘宝API接口，可以运用到多种业务场景中

淘宝API接口可以运用到多种业务场景中&#xff0c;以下列举了一些主要的场景&#xff1a; 商品信息展示&#xff1a;通过调用淘宝API详情接口&#xff0c;可以获取商品的详细信息&#xff0c;如商品标题、价格、库存、销量、评价等数据。这些信息可以用于在自己的网站或应用程…
阅读更多...
@24计算机考研er，招生简章超全汇总来了！持续更新请收藏

@24计算机考研er，招生简章超全汇总来了！持续更新请收藏

今天是8月最后一天&#xff0c;大家复习进度如何&#xff1f;目前已经有多所计算机招生院校公布了24考研的研招通知&#xff0c;包含&#xff1a;招生简章、专业目录、参考书目、考试大纲等。学姐整理成了24计算机考研招生官方信息汇总表&#xff01;终于不用自己一个个去官网翻…
阅读更多...
泼辣修图Ploarr5.11.7电脑最新简体中文版下载

泼辣修图Ploarr5.11.7电脑最新简体中文版下载

泼辣修图专业版是一款强大的专业修图软件&#xff0c;拥有上百款调色工具还有丰富的图层素材&#xff0c; 更有智能的人像修饰面板&#xff0c;具备物体识别的智能蒙板&#xff0c;高效的滤镜管理系统和强大的文字工具&#xff0c;支持批量处理。一切围绕摄影&#xff0c;无论是…
阅读更多...
XSS漏洞及分析·

XSS漏洞及分析·

XSS漏洞和分析 知识点模板字符串定时器焦点jquerydom破坏 漏洞复现 xss测试网站&#xff1a;https://xss.pwnfunction.com/ 知识点 模板字符串 模板字面量是用反引号&#xff08;&#xff09;分隔的字面量&#xff0c;允许多行字符串、带嵌入表达式的字符串插值和一种叫带标签…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023