目录

1. 认识队列结构
2. 实现队列结构封装
3. 实战一:最近的请求次数
3.1 题目描述
3.2 解一:队列
4. 实战二:无法吃午餐的学生数量
4.1 题目描述
4.2 解一:队列
5. 实战三:字符串中的第一个唯一字符
5.1 题目描述
5.2 解一:哈希表
5.3 解二:队列

1. 认识队列结构

  1. 队列是一个 先进先出(FIFO) 的数据结构

  2. js 中没有队列,但我们可以用 数组或链表 实现队列的所有功能

  3. 队列的常用操作:

    1. enqueue(element):向队列尾部添加一个(多个)新的项
    2. dequeue():移除队列的第一项,并返回被移除的元素
    3. front/peek():返回队列中的第一个元素
    4. isEmpty():判断队列是否为空
    5. size():返回队列的元素个数

队列的结构示意图:

image.png

2. 实现队列结构封装

队列的实现和栈一样也有两种实现方式:

  1. 基于 数组 实现
  2. 基于 链表 实现

链表也是一种数据结构,js 中没有自带链表结构,后续会写关于链表的文章,本章先使用数组来实现。

实现:

ts
// 封装一个队列 export default class ArrayQueue<T = any> { private data: T[] = []; constructor(data: T[]) { this.data = data || []; } 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; } }

测试:

ts
const queue = new ArrayQueue<number>(); queue.push(1); queue.push(2); queue.pop(); queue.push(3); console.log(queue); // ArrayQueue { data: [ 2, 3 ] }

3. 实战一:最近的请求次数

这是 Leetcode 上的第 933 道题,难度为 简单

3.1 题目描述

写一个 RecentCounter 类来计算特定时间范围内最近的请求。

请你实现 RecentCounter 类:

  • RecentCounter() 初始化计数器,请求数为 0 。
  • int ping(int t) 在时间 t 添加一个新请求,其中 t 表示以毫秒为单位的某个时间,并返回过去 3000 毫秒内发生的所有请求数(包括新请求)。确切地说,返回在 [t-3000, t] 内发生的请求数。

保证 每次对 ping 的调用都使用比之前更大的 t 值。

示例 1:

输入: ["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]] 输出: [null, 1, 2, 3, 3] 解释: RecentCounter recentCounter = new RecentCounter(); recentCounter.ping(1); // requests = [1],范围是 [-2999,1],返回 1 recentCounter.ping(100); // requests = [1, 100],范围是 [-2900,100],返回 2 recentCounter.ping(3001); // requests = [1, 100, 3001],范围是 [1,3001],返回 3 recentCounter.ping(3002); // requests = [1, 100, 3001, 3002],范围是 [2,3002],返回 3

提示:

  • 1 <= t <= 109
  • 保证每次对 ping 调用所使用的 t 值都 严格递增
  • 至多调用 ping 方法 104 次

3.2 解一:队列

思路:

我们可以用一个队列维护发生请求的时间,当在时间 t 收到请求时,将时间 t 入队。 保证队列的 尾部值 减去队列的 首部值 小于等于 3000,队列中的元素数量即为 最近的请求次数

代码:

ts
class RecentCounter { queue: ArrayQueue<number>; constructor() { this.queue = new ArrayQueue<number>(); } ping(t: number): number { this.queue.enqueue(t); while (this.queue.peek() < t - 3000) { this.queue.dequeue(); } return this.queue.size(); } } /** * Your RecentCounter object will be instantiated and called as such: * var obj = new RecentCounter() * var param_1 = obj.ping(t) */

复杂度分析:

  • 时间复杂度:均摊 O(1),每个元素至多入队出队各一次。

  • 空间复杂度:O(L),其中 L 为队列的最大元素个数。

4. 实战二:无法吃午餐的学生数量

这是 Leetcode 上的第 1700 道题,难度为 简单

4.1 题目描述

学校的自助午餐提供圆形和方形的三明治,分别用数字 0 和 1 表示。所有学生站在一个队列里,每个学生要么喜欢圆形的要么喜欢方形的。
餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个  里,每一轮:

  • 如果队列最前面的学生 喜欢 栈顶的三明治,那么会 拿走它 并离开队列。
  • 否则,这名学生会 放弃这个三明治 并回到队列的尾部。

这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。

给你两个整数数组 students 和 sandwiches ,其中 sandwiches[i] 是栈里面第 i​​​​​​ 个三明治的类型(i = 0 是栈的顶部), students[j] 是初始队列里第 j​​​​​​ 名学生对三明治的喜好(j = 0 是队列的最开始位置)。请你返回无法吃午餐的学生数量。

示例 1:

输入: students = [1,1,0,0], sandwiches = [0,1,0,1] 输出: 0 解释: - 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [1,0,0,1]。 - 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [0,0,1,1]。 - 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [0,1,1],三明治栈为 sandwiches = [1,0,1]。 - 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [1,1,0]。 - 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [1,0],三明治栈为 sandwiches = [0,1]。 - 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [0,1]。 - 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [1],三明治栈为 sandwiches = [1]。 - 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [],三明治栈为 sandwiches = []。 所以所有学生都有三明治吃。

示例 2:

输入: students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1] 输出: 3

提示:

  • 1 <= students.length, sandwiches.length <= 100
  • students.length == sandwiches.length
  • sandwiches[i] 要么是 0 ,要么是 1 。
  • students[i] 要么是 0 ,要么是 1 。

4.2 解一:队列

思路: 我们可以维护两个队列,一个是学生队列,一个是三明治队列。

循环比较 学生队列三明治队列头部第一个元素,如果相同则都 移除 它们,如果不相同则将学生队列的头部元素移到尾部,直到碰到下一组相同的两个头部元素 或者 学生队列所有学生都不喜欢三明治队列的第一个三明治。

代码:

ts
function countStudents(students: number[], sandwiches: number[]): number { const studentsQueue = new ArrayQueue<number>(students); const sandwichesQueue = new ArrayQueue<number>(sandwiches); let count = 0; while (studentsQueue.size()) { if (studentsQueue.peek() === sandwichesQueue.peek()) { studentsQueue.dequeue(); sandwichesQueue.dequeue(); count = 0; } else { studentsQueue.enqueue(studentsQueue.dequeue()!); count++; } if (count === studentsQueue.size()) return sandwichesQueue.size(); } return 0; }

复杂度分析

  • 时间复杂度:O(n),其中 n 是学生的数量。
  • 空间复杂度:O(1)

5. 实战三:字符串中的第一个唯一字符

这是 Leetcode 上的第 387 道题,难度为 简单

5.1 题目描述

给定一个字符串 s ,找到 它的第一个不重复的字符,并返回它的索引 。如果不存在,则返回 -1 。

示例 1:

输入: s = "leetcode" 输出: 0

示例 2:

输入: s = "loveleetcode" 输出: 2

示例 3:

输入: s = "aabb" 输出: -1

提示:

  • 1 <= s.length <= 105
  • s 只包含小写字母

5.2 解一:哈希表

思路:

维护一个 map,分两次遍历字符串

  1. 第一次遍历存储每个字符对应的出现次数
  2. 第二次遍历取出第一个只出现第一次的字符

代码:

ts
function firstUniqChar(s: string): number { const map = new Map<string, number>(); for (let i = 0; i < s.length; i++) { let n = map.get(s[i]); n ? map.set(s[i], n + 1) : map.set(s[i], 1); } for (let i = 0; i < s.length; i++) { if (map.get(s[i]) === 1) return i; } return -1; }

复杂度分析:

  • 时间复杂度:O(n)
  • 空间复杂度:O(∣Σ∣),其中 Σ 是字符集,在本题中 s 只包含小写字母,因此 ∣Σ∣≤26 。我们需要 O(∣Σ∣) 的空间存储哈希映射。

5.3 解二:队列

思路:

维护一个队列,按照顺序存储每一个字符以及它们第一次出现的位置。当我们对字符串进行遍历时,设当前遍历到的字符为 c,如果 c 不在哈希映射中,我们就将 c 与它的索引作为一个二元组放入队尾,否则我们就需要检查队列中的元素是否都满足「只出现一次 的要求,即我们不断地根据哈希映射中存储的值(是否为 −1)选择弹出队首的元素,直到队首元素 「真的」 只出现了一次或者队列为空。

在遍历完成后,如果队列为空,说明没有不重复的字符,返回 −1,否则队首的元素即为第一个不重复的字符以及其索引的二元组

代码:

ts
function firstUniqChar(s: string): number { const map = new Map<string, number>(); const queue = new ArrayQueue<[string, number]>(); for (let i = 0; i < s.length; i++) { if(!map.has(s[i])) { map.set(s[i], i) queue.enqueue([s[i], i]); } else { map.set(s[i], -1) while(queue.size() && map.get((queue.peek() as [string,number])[0]) === -1) { queue.dequeue() } } } return queue.size() ? (queue.peek() as [string, number])[1] : -1; }

复杂度分析:

  • 时间复杂度:O(n)
  • 空间复杂度:O(∣Σ∣)
如果对你有用的话,可以打赏哦
打赏
ali pay
wechat pay

本文作者:叶继伟

本文链接:

版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!