重读《学习JavaScript数据结构与算法-第三版》- 第5章 队列

定场诗

马瘦毛长蹄子肥，儿子偷爹不算贼，瞎大爷娶个瞎大奶奶，老两口过了多半辈，谁也没看见谁！

前言

本章为重读《学习javascript数据结构与算法-第三版》的系列文章，主要讲述队列数据结构、双端队列数据结构以及队列相关应用。

队列

队列是遵循先进先出（fifo）原则的一组有序的项。队列在尾部添加元素，并从顶部移除元素。最新添加的元素必须排在队列的末尾。现实中常见的队列就是排队，计算机科学中，常见的例子是打印队列，如文档按顺序打印，第一个发送到打印队列的文档优先被打印。

实现队列

/**
 * class queue 队列类
 * 特点：先进先出
 */
class queue {
  construcor () {
    // 存储数据
    this.items = {}
    // 队列头部元素索引
    this.lowestcount = 0
    // 队列尾部元素索引
    this.count = 0
  }

  /**
   * enqueue() 添加元素到队列 - 先进先出
   * @param {*} element 添加到队列的元素
   */
  enqueue (elemenet) {
    this.items[this.count] = element
    this.count++
  }

  /**
   * dequeue() 移除队列头部元素 - 先进先出
   * @returns {*} result 返回头部元素
   */
  dequeue () {
    if (this.isempty()) {
      return undefined
    }
    let result = this.items[this.lowestcount]
    delete this.items[this.lowestcount]
    this.lowestcount++
    return result
  }

  /**
   * peek() 返回队列头部元素
   * @returns {*}
   */
  peek () {
    if (this.isempty()) {
      return undefined
    }
    return this.items[this.lowestcount]
  }

  /**
   * isempty() 判断队列是否为空
   * @returns {boolean}
   */
  isempty () {
    return this.count === this.lowestcount
  }

  /**
   * size() 队列长度
   * @returns {number}
   */
  size () {
    return this.count - this.lowestcount
  }

  /**
   * clear() 清空队列
   */
  clear () {
    this.items = {}
    this.count = 0
    this.lowestcount = 0
  }

  /**
   * tostring() 返回队列的字符串结构
   * @returns {string}
   */
  tostring () {
    if (this.isempty()) {
      return ''
    }
    let queuestr = `${this.items[this.lowestcount]}`
    for (let i = this.lowestcount + 1; i < this.count; i++) {
      queuestr = `${queuestr},${this.items[i]}`
    }
    return queuestr
  }
}

使用队列

// 实例化队列
const queue = new queue()

// 判断队列是否为空
console.log(queue.isempty()) // true

// 向队列中添加元素
queue.enqueue('john')
queue.enqueue('jack')

console.log(queue.tostring()) // john,jack

queue.enqueue('camila')

console.log(queue.tostring()) // john,jack

console.log(queue.size()) // 3

console.log(queue.isempty()) // false

以上操作示意图：

console.log(queue.dequeue()) // john
console.log(queue.dequeue()) // jack
console.log(queue.tostring()) // camila

以上操作示意图

双端队列

双端队列是一种允许我们同时从前端和后端添加和移除元素的特殊队列。在计算机科学中双端队列常见应用是存储一系列的撤销操作。

1. 当用户在软件中进行了操作时，该操作从尾部进入双端队列；
2. 当用户点击撤销按钮时，从双端队列的尾部移除；
3. 当队列中的操作达到预定义的一定数量后，最先存入的操作会被移除(头部移除)

双端队列同时遵守了先进先出和后进先出的原则

实现双端队列

/**
 * class deque 双端队列
 * 特点：支持先进先出、后进先出
 */
class deque {
  constructor () {
    this.items = {}
    this.count = 0
    this.lowestcount = 0
  }

  /**
   * addfront() 从头部插入
   * @param {*} element 待插入队首的元素
   */
  addfront (element) {
    this.lowestcount--
    this.items[this.lowestcount] = element
  }

  /**
   * addback() 从尾部插入
   * @param {*} element 待插入队尾的元素
   */
  addback (element) {
    this.items[this.count] = element
    this.count++
  }

  /**
   * removefront() 队首移除元素
   * @returns {*}
   */
  removefront () {
    if (this.isempty()) {
      return undefined
    }
    let result = this.items[this.lowestcount]
    delete this.items[this.lowestcount]
    this.lowestcount++
    return result
  }

  /**
   * removeback() 队尾移除元素
   * @returns {*}
   */
  removeback () {
    if (this.isempty()) {
      return undefined
    }
    let result = this.items[this.count -1]
    delete this.items[this.count - 1]
    this.count--
    return result
  }

  /**
   * isempty() 判断是否为空
   * @returns {boolean} 是否为空
   */
  isempty () {
    return this.count === this.lowestcount
  }

  /**
   * size() 返回队列的长度
   * @returns {number} 队列的长度
   */
  size () {
    return this.count - this.lowestcount
  }

  /**
   * clear() 清空队列
   */
  clear () {
    this.items = {}
    this.count = 0
    this.lowestcount = 0
  }

  /**
   * peekfront() 获取队首元素
   * @returns {*}
   */
  peekfront () {
    if (this.isempty()) {
      return undefined
    }
    return this.items[this.lowestcount]
  }

  /**
   * peekback() 获取队尾元素
   * @returns {*}
   */
  peekback () {
    if (this.isempty()) {
      return undefined
    }
    return this.items[this.count - 1]
  }

  /**
   * tostring() 展示字符串形式
   * @returns {*}
   */
  tostring () {
    if (this.isempty()) {
      return ''
    }
    let str = `${this.items[this.lowestcount]}`
    for (let i = this.lowestcount + 1; i < this.count; i++) {
      str = `${str},${this.items[i]}`
    }
    return str
  }
}

使用双端队列

const deque = new deque()

console.log(deque.isempty()) // true

deque.addfront('宋江')
deque.addfront('晁盖')
deque.addback('吴用')

console.log(deque.size()) // 3
console.log(deque.tostring()) // 晁盖,宋江,吴用

console.log(deque.removefront()) // 晁盖
console.log(deque.removeback()) // 吴用

console.log(deque.tostring()) // 宋江
console.log(deque.size()) // 1

实战应用

循环队列 - 模拟击鼓传花游戏

规则：

1. 使用队列模拟击鼓传花
2. 当执行一定的约定次数(每次都随机一个数)时，花在谁手里，谁被淘汰
3. 重复执行游戏，直到剩下最后一人，为胜利者

/**
 * hotpotato() 模拟击鼓传花游戏
 * @param {array} elementlist 需传入的参与游戏的人员列表
 * @returns {object} 返回信息：淘汰者和胜利者
 */
function hotpotato (elementlist) {
  // 实例化队列，将元素放入队列
  let queue = new queue()
  elementlist.foreach((value) => {
    queue.enqueue(value)
  })

  // 淘汰的人
  let elimitatedlist = []

  // 开始游戏，直到队列中剩余1人
  while (queue.size() > 1) {
    // 为了让游戏更加有意思，每次停止的位置进行随机处理
    for (let i = 0; i < math.floor(math.random() * 10); i++) {
      // 取出头部第一个元素，然后执行插入
      queue.enqueue(queue.dequeue())
    }
    // 此时拥有花的人，淘汰
    elimitatedlist.push(queue.dequeue())
  }

  // 返回
  return {
    elimitatedlist,
    winner: queue.dequeue()
  }
}

let elementlist = [
  '孙悟空',
  '唐僧',
  '如来佛祖',
  '玉帝',
  '王母'
]

// 调用函数，传入elementlist，同时约定第6次时，拥有花的小伙伴被淘汰...
let result = hotpotato(elementlist, 6)
console.log(result)

result.elimitatedlist.foreach((name) => {
  console.log(`${name}被淘汰了...`)
})

console.log(`${result.winner}胜利了...`)

以上代码运行效果 -- 展示其中一次的执行结果

{ elimitatedlist: [ '唐僧', '王母', '孙悟空', '如来佛祖' ], winner: '玉帝' }

唐僧被淘汰了...

王母被淘汰了...

孙悟空被淘汰了...

如来佛祖被淘汰了...

玉帝胜利了...

回文检查器

什么是回文？

回文是正反都能读通的单词、词组、数或一系列字符的序列，例如：aba、madam

那如何实现回文检查器呢？

1. 使用反转排列字符串与原字符串进行比较

/**
 * palindromechecker() 回文检查器
 * @param {string} str 待检查的字符串
 * @returns {boolean}
 */
function palindromechecker (str) {
  // 检测是否是合法字符串
  if (str === undefined || str === null || (str !== null && str.length === 0)) {
    return false
  }
  return str.split('').reverse().join('') === str
}

let str = 'aba'
console.log(palindromechecker(str)) // true

2. 使用数据结构-栈实现回文检查器

/**
 * palindromechecker() 回文检查器
 * @param {string} str 待检查的字符串
 * @returns {boolean}
 */
function palindromechecker (str) {
  // 检测是否是合法字符串
  if (str === undefined || str === null || (str !== null && str.length === 0)) {
    return false
  }
  let stack = new stack()
  // 分割字符串
  for (let i = 0; i < str.length; i++) {
    stack.push(str[i])
  }

  let reversestr = ''
  while (!stack.isempty()) {
    reversestr += stack.pop()
  }
  return str === reversestr
}

let str = 'aba'
console.log(palindromechecker(str)) // true

此处栈 class stack的实现，请参考上一篇文章：重读《学习javascript数据结构与算法-第三版》- 第4章 栈

3. 使用双端队列实现回文检查器

/**
 * palindromechecker() 回文检查器
 * @param {string} str 待检查的字符串
 * @returns {boolean}
 */
function palindromechecker (str) {
  // 检测是否是合法字符串
  if (str === undefined || str === null || (str !== null && str.length === 0)) {
    return false
  }

  let deque = new deque()

  for (let i = 0; i < str.length; i++) {
    deque.addback(str[i])
  }

  // 设置是否是回文的标记
  let isequal = true
  while (deque.size() > 1 && isequal) {
    // 取出收尾进行比较
    let front = deque.peekfront()
    let back = deque.peekback()
    
    if (front !== back) {
      isequal = false
    }
  }

  return isequal
}

let str = 'abc'
console.log(palindromechecker(str)) // false
str = 'aba'
console.log(palindromechecker(str)) // true

后记

以上就是胡哥今天给大家分享的内容，喜欢的小伙伴记得收藏、转发、点击右下角按钮在看，推荐给更多小伙伴呦，欢迎多多留言交流...

胡哥有话说，一个有技术，有情怀的胡哥！京东开放平台首席前端攻城狮。与你一起聊聊大前端，分享前端系统架构，框架实现原理，最新最高效的技术实践！

长按扫码关注，更帅更漂亮呦！关注胡哥有话说公众号，可与胡哥继续深入交流呦！