javascript 队列(queue)算法与说明

队列的介绍

队列是一种遵从先进先出（FIFO）先来先服务的有序的项，就是喝茶拿号模式（最前的号，最先进去）。队列在尾部添加新元素，并从顶部移除元素。最新添加的元素必须排在队列的末尾。

队列算法实例

1.我有三个元素John,Jack,Camila,按循序添加三个元素，就会得到下图的一个队列。



2.队列删除。

let queue = new Queue()
queue.enqueue('John')
queue.enqueue('Jack')
queue.enqueue('Camila')//John,Jack,Camila添加完毕队列
queue.dequeue()//删除一个元素 Jack,Camila
queue.dequeue()//删除一个元素 Camila

ES6队列实现代码：

let Queue = (function () {

const items = new WeakMap();//WeakMap对象是密钥/值对的集合，其中密钥被弱引用。键必须是对象，值可以是任意值。

class Queue {

constructor () {
items.set(this, []);
}

enqueue(...element) {//向队列尾部添加一个（或多个）新的项
let q = items.get(this);
q.push(...element);
}

dequeue() {//移除队列的第一个（排在队列最前面的）项，并返回被移除的元素。
let q = items.get(this);
let r = q.shift();
return r;
}

front() {//返回队列中第一个元素——最先被添加，也将是最先被移除的元素。队列不做任何变动（不移除元素，只返回元素信息）
let q = items.get(this);
return q[0];
}

isEmpty(){//如果队列中不包含任何元素，返回true，否则返回false。
return items.get(this).length == 0;
}

size(){//返回队列包含的元素个数，与数组的length属性类似。
let q = items.get(this);
return q.length;
}

clear(){//清空队列里面的元素。
items.set(this, []);
}

print(){//打印队列为String到控制台
console.log(this.toString());
}

toString(){//输出队列以String模式。
return items.get(this).toString();
}
}
return Queue;
})();

let queue = new Queue();//实例化

队列的种类

在计算机科学中，队列在原先的版本中，有几种修改版本分别是优先队列和循环队列。

优先队列

优先队列，就是元素添加和移除是基于优先级的。就是在原来的排队中在分优先级。现实例子就是医院排队看病，病情严重的优先排在前面进行治疗。

let priorityQueue = new PriorityQueue()
priorityQueue.enqueue('John'，2)//添加元素和优先级
priorityQueue.enqueue('Jack'，1)
priorityQueue.enqueue('Camila'，1)//Jack,Camila,John添加完毕队列

ES6代码实例：

let PriorityQueue = (function () {

class QueueElement {//优先队列元素包含（元素，优先级）
constructor(element, priority){
this.element = element;
this.priority = priority;
}
}

const items = new WeakMap();

class PriorityQueue {

constructor () {
items.set(this, []);
}

enqueue(element, priority){//主要修改，在新元素添加的时候，放到优先级相同位置，但是先添加到队列的元素，我们同样遵从先进先出的原则。
let queueElement = new QueueElement(element, priority);

let q = items.get(this);

let added = false;
for (let i=0; i<q.length; i++){
if (queueElement.priority < q[i].priority){
q.splice(i,0,queueElement);
added = true;
break;
}
}
if (!added){
q.push(queueElement);
}

items.set(this, q);
};

dequeue() {
let q = items.get(this);
let r = q.shift();
items.set(this, q);
return r;
}

front() {
let q = items.get(this);
return q[0];
}

isEmpty(){
return items.get(this).length == 0;
}

size(){
let q = items.get(this);
return q.length;
}

clear(){
items.set(this, []);
}

print(){
let q = items.get(this);
for (let i=0; i<q.length; i++){
console.log(`${q[i].element}  - ${q[i].priority}`);
}
};
}
return PriorityQueue;
})();

let priorityQueue = new PriorityQueue();

循环队列-击鼓传花

循环队列。现实例子就是击鼓传花(Hot Potato)，在游戏中，孩子们围着圆圈，把花尽快地传递给旁边的人。某一时刻传花停止，这个时候花在谁手里，谁就退出圆圈结束游戏。重复这个过程，直到只剩一个孩子(胜利)。

let names = ['John','Jack','Camila','Ingrid','Carl'];
let winner = hotPotato(names, 7);
console.log（winner+"胜利者"）
//Camila被淘汰。
//Jack被淘汰。
//Carl被淘汰。
//Ingrid被淘汰。
//John胜利者

ES6循环队列实例：

let Queue = (function () {

const items = new WeakMap();//WeakMap对象是密钥/值对的集合，其中密钥被弱引用。键必须是对象，值可以是任意值。

class Queue {

constructor () {
items.set(this, []);
}

enqueue(...element) {//向队列尾部添加一个（或多个）新的项
let q = items.get(this);
q.push(...element);
}

dequeue() {//移除队列的第一个（排在队列最前面的）项，并返回被移除的元素。
let q = items.get(this);
let r = q.shift();
return r;
}

front() {//返回队列中第一个元素——最先被添加，也将是最先被移除的元素。队列不做任何变动（不移除元素，只返回元素信息）
let q = items.get(this);
return q[0];
}

isEmpty(){//如果队列中不包含任何元素，返回true，否则返回false。
return items.get(this).length == 0;
}

size(){//返回队列包含的元素个数，与数组的length属性类似。
let q = items.get(this);
return q.length;
}

clear(){//清空队列里面的元素。
items.set(this, []);
}

print(){//打印队列为String到控制台
console.log(this.toString());
}

toString(){//输出队列以String模式。
return items.get(this).toString();
}
}
return Queue;
})();

function hotPotato (nameList, num){
let queue = new Queue();

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

let eliminated = '';
while (queue.size() > 1){
for (let i=0; i<num; i++){
queue.enqueue(queue.dequeue());//从队列开头移除一项，再将其添加到队列末位。
}
eliminated = queue.dequeue();//传递次数达到指定的数字，那个人淘汰。
console.log(eliminated + '被淘汰。');
}

return queue.dequeue();
}