javascript数据结构-队列和双端队列

1. 队列数据结构

队列是遵循先进先出（FIFO，也称为先来先服务）原则的一组有序的项。队列在尾部添加新元素，并从顶部移除元素。最新添加的元素必须排在队列的末尾。

1.1 创建队列

首先需要一个用于存储队列中元素的数据结构。可以使用数组，但是为了写出一个在获取元素时更高效的数据结构，将使用一个对象来存储元素。会发现Queue类和Stack类非常类似，只是添加和移除元素的原则不同。

export default class Queue {
  constructor() {
    this.count = 0;
    this.lowestCount = 0;
    this.items = {};
  }

  // enqueue(element(s)): 向队列尾部添加一个或多个新的项
  enqueue(element) {
    this.items[this.count] = element
    this.count++
  }

  // dequeue(): 移除队列的第一项（即排在队列最前面的项）并返回被移除的元素
  dequeue() {
    if(this.isEmpty()) {
      return undefined
    }
    const result = this.items[this.lowestCount]
    delete this.items[this.lowestCount]
    this.lowestCount++
    return result
  }

  // peek(): 返回队列中第一个元素--最先被添加，也将是最先被移除的元素。队列不做任何变动（不移除元素，只返回元素信息）
  peek() {
    if(this.isEmpty()) {
      return undefined
    }
    return this.items[this.lowestCount]
  }

  // isEmpty(): 如果队列中不包含任何元素，返回true，否则返回false
  isEmpty() {
    return this.count - this.lowestCount === 0
  }

  // size(): 返回队列包含的元素个数，与数组的length属性类似
  size() {
    return this.count - this.lowestCount
  }

  // 清理队列
  clear() {
    this.count = 0;
    this.lowestCount = 0
    this.items = {}
  }

  // 创建一个toString方法
  toString() {
    if(this.isEmpty()) {
      return ""
    }
    let objString = `${this.items[this.lowestCount]}`
    for(let i = this.lowestCount + 1; i < this.count; i++) {
      objString = `${objString}, ${this.items[i]}`
    }

    return objString
  }

}

1.2 使用Queue类

// Queue：首先是实例化刚刚创建的Queue类
const queue = new Queue()
console.log(queue.isEmpty())  //true,队列为空

// 向队列添加三个元素
queue.enqueue('John')
queue.enqueue('Jack')
queue.enqueue('ytllll')

console.log(queue.toString()) //John, Jack, ytllll

queue.enqueue("Kotoko")
console.log(queue.toString()) //John, Jack, ytllll, Kotoko
console.log(queue.size()) //4
console.log(queue.isEmpty()) //false

// 删除前两个元素
queue.dequeue()
queue.dequeue()
console.log(queue.toString()) //ytllll, Kotoko

2. 双端队列数据结构

双端队列（deque，或称double-ended queue）是一种运行我们同时从前端和后端添加和移除元素的特殊队列。
双端队列在现实生活中的例子有电影院、餐厅中排队的队伍等。

2.1 创建Deque类

export default class Deque {
  constructor() {
    this.count = 0;
    this.lowestCount = 0;
    this.items = {};
  }

  // 该方法在双端队列前端添加新的元素
  addFront(element) {
    if(this.isEmpty()) {
      this.addBack(element)
    }else if(this.lowestCount > 0) {
      this.lowestCount--
      this.items[this.lowestCount] = element
    }else {
      for(let i = this.count; i > 0; i--) {
        this.items[i] = this.items[i - 1]
      }
      this.count++
      this.lowestCount = 0
      this.items[0] = element
    }
  }

  // 向双端队列后端添加新的元素
  addBack(element) {
    this.items[this.count] = element
    this.count++
  }

  // 该方法会从双端队列前端移除第一个元素并返回
  removeFront() {
    if(this.isEmpty()) {
      return undefined
    }
    const result = this.items[this.lowestCount]
    delete this.items[this.lowestCount]
    this.lowestCount++
    return result
  }

  // 该方法会从双端队列后端移除第一个元素并返回
  removeBack() {
    if (this.isEmpty()) {
      return undefined
    }
    this.count--
    const result = this.items[this.count]
    delete this.items[this.count]
    return result
  }

  // 该方法会从双端队列前端返回第一个元素
  peekFront() {
    if(this.isEmpty()) {
      return undefined
    }
    return this.items[this.lowestCount]
  }

  // 该方法会从双端队列后端返回第一个元素
  peekBack() {
    if (this.isEmpty()) {
      return undefined
    }
    return this.items[this.count - 1]
  }

  // isEmpty(): 如果队列中不包含任何元素，返回true，否则返回false
  isEmpty() {
    return this.count - this.lowestCount === 0
  }

  // size(): 返回队列包含的元素个数，与数组的length属性类似
  size() {
    return this.count - this.lowestCount
  }

  // 清理队列
  clear() {
    this.count = 0;
    this.lowestCount = 0
    this.items = {}
  }

  // 创建一个toString方法
  toString() {
    if(this.isEmpty()) {
      return ""
    }
    let objString = `${this.items[this.lowestCount]}`
    for(let i = this.lowestCount + 1; i < this.count; i++) {
      objString = `${objString}, ${this.items[i]}`
    }

    return objString
  }
}

2.2 使用Deque类

// Deque：实例化Deque类
const deque = new Deque()
console.log(deque.isEmpty()) //true
// 向双端队列后端加入两个元素
deque.addBack('John')
deque.addBack('Jack')
console.log(deque.toString()) //John, Jack
// 向双端队列前端加入两个元素
deque.addFront('ytllll')
deque.addFront('Kotoko')
console.log(deque.toString()) //Kotoko, ytllll, John, Jack
console.log(deque.size()) //4
console.log(deque.isEmpty()) //false
// 取队列的第一个元素
console.log(deque.peekFront()) //Kotoko
// 取队列的最后一个元素
console.log(deque.peekBack()) //Jack
// 移除队列第一个元素
deque.removeFront()
console.log(deque.toString()) //ytllll, John, Jack
// 移除队列最后一个元素
deque.removeBack()
console.log(deque.toString()) //ytllll, John

3. 使用队列和双端队列来解决问题

3.1 循环队列——击鼓传花游戏

在这个游戏中，孩子们围成一个圆圈，把花尽快的传递给旁边的人。某一时刻传花停止，这个时候花在谁手里，谁就退出圆圈，结束游戏。重复这个过程，直到只剩下一个孩子（胜者）。
接下来使用队列来实现这个游戏：

function hotPotato(elementList, num) {
  // 定义一个空队列
  const queue = new Queue()
  // 定义一个保存淘汰者的数组
  const eliminatedList = []

  for(let i = 0; i < elementsList.length; i++) {
    // 遍历传入的elementsList数组，逐个传入queue队列
    queue.enqueue(elementsList[i])
  }

  while(queue.size() > 1) {
    for(let i = 0; i < num; i++) {
      // 从队列头开始，移除一项再将返回值添加会队列，模拟一次传递
      queue.enqueue(queue.dequeue) 
    }
    // 循环结束，传到第num次的人淘汰，并加入数组
    eliminatedList.push(queue.dequeue)
  }

  return {
    eliminated: eliminatedList,
    // 队列中剩下的最后一个人就是胜者
    winner: queue.dequeue()
  }

}

const names = ['John', 'Jack', 'Camila', 'Ingrid', 'Carl']
const result = hotPotato(names, 7)
result.eliminated.forEach(name => {
  console.log(`${name}在击鼓传花游戏中被淘汰`)
})
console.log(`胜利者： ${result.winner}`)

以上函数输出如下：
Camila在击鼓传花游戏中被淘汰
Jack在击鼓传花游戏中被淘汰
Carl在击鼓传花游戏中被淘汰
Ingrid在击鼓传花游戏中被淘汰
胜利者：John
下图模拟了这个输出过程：

3.2 回文检查器

维基百科对回文的解释：回文是正反都能读通的单词、词组、数或一系列字符的序列，例如madam或racecar。
有不同的算法可以检查一个词组或字符串是否回文。最简单的方式是将字符串反向排列并检查它和原字符串是否相同。如果两者相同，那么它就是一个回文。我们也可以用栈来完成，但是利用数据结构来解决这个问题最简单方法是使用双端队列。
下面使用一个双端队列来解决这个问题：

function palindromeChecker(aString) {
  if(aString === undefined || aString === null || (aString !== null && aString.length === 0)) {
    return false
  }
  const deque = new Deque()
  const lowerString = aString.toLocaleLowerCase().split(' ').join('')
  let isEqual = true
  let firstChar, lastChar

  for(let i = 0; i < lowerString.length; i++) {
    deque.addBack(lowerString.charAt(i))
  }

  while(deque.size() > 1 && isEqual) {
    firstChar = deque.removeFront()
    lastChar = deque.removeBack()
    if(firstChar !== lastChar) {
      isEqual = false
    }
  }

  return isEqual
}

console.log('a', palindromeChecker('a'));
console.log('aa', palindromeChecker('aa'));
console.log('kayak', palindromeChecker('kayak'));
console.log('level', palindromeChecker('level'));
console.log('Step on no pets', palindromeChecker('Step on no pets'));

以上输出都是true