queue.js

队列

一些队列可用的方法：

• enqueue(element(s)): 向队列尾部添加一个或多个新的项
• dequeue(): 移除队列的第一项并返回被移除的元素
• peek(): 返回队列中第一个元素
• isEmpty(): 如果队列不包含任何元素，返回true，否则false
• size(): 返回队列包含的元素个数，与数组的length属性类似

class Quene {
	constructor() {
		this.count = 0;						// 控制队列大小
		this.lowestCount = 0;			// 从队列前端移除元素，用于追踪第一个元素
		this.items = {};
	}

	enqueue(element) {
		this.items[this.count] = element;
		this.count++;
	}

	dequeue() {
		if (this.isEmpty()) {
			return undefined;
		}
		const result = this.item[this.lowestCount];
		delete this.items[this.lowestCount];
		this.lowestCount++;
		return result;
	}

	peek() {
		if (this.isEmpty()) {
			return undefined;
		}
		return this.items[this.lowestCount];
	}

	isEmpty() {
		return this.count - this.lowestCount === 0;
	}

	size() {
		return this.count - this.lowestCount;
	}

	clear() {
		this.items = {};
		this.count = 0;
		this.lowestCount = 0;
	}

	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;
	}
}

双端队列

double-ended queue，允许同时从前端和后端添加和移除元素的特殊队列。

使用场景：存储一系列的撤销操作。当用户在软件中进行了一个操作，该操作被存在一个双端队列中（就像在一个
栈里），当用户点击撤销按钮时，该操作会被从双端队列中弹出，表示它被从后面移除。由于双端队列同时遵守先进先出和
后进先出原则，可以说是队列和栈相结合的数据结构。

一些双端队列可用的方法：

• addFront(element): 在双端队列前端添加新的元素
• addBack(element): 在双端队列后端添加新的元素（同Queue的enqueue）
• removeFront(): 从双端队列前端移除第一个元素（同Queeu的dequeue）
• removeBack(): 从双端队列后端移除第一个元素（同Stack的pop）
• peekFront(): 返回双端队列前端中第一个元素（同Queue的peek）
• peekBack(): 返回双端队列后端中第一个元素（同Stack的peek）
• size(): 同Quene的size
• isEmpty(): 同Quene的isEmpty
• clear(): 同Quene的clear
• toString(): 同Quene的toString

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;
		}
	}
}

队列应用-击鼓传花

击鼓传花（hot potato）--循环队列，孩子们围成圈，把花尽快传递给身边人，某一时刻游戏停止，谁手上有花谁就退出圆圈、结束游戏，重复直至一个孩子胜利。

function hotPotato(elementList, num) {
	const queue = new Quene();
	const elimitatedList = [];

	for (let i = 0; i < elementList.length; i++) {
		queue.enqueue(elementList[i]);
	}

	while (queue.size() > 1) {
		for (let i = 0; i < num; i++) {
			queue.enqueue(queue.dequeue());
		}
		elimitatedList.push(queue.dequeue());
	}

	return {
		eliminated: elimitatedList,
		winner: queue.dequeue()
	};
}

回文检查器

回文：正反都能读通的单词、词组、数或一系列字符的序列，如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('Was it a car or a cat I saw', palindromeChecker('Was it a car
or a cat I saw'));
console.log('Step on no pets', palindromeChecker('Step on no pets'));