队列的定义
队列(Queue)是一种遵从先进先出(First in, first out。简称FIFO)原则的有序集合。
定义队列的方法
入队
方法:enqueue()
语法:arrayQueue.enqueue(element1,element2…elementX)
参数:至少有一个元素
描述:添加一个或几个新元素在队列尾部。
出队
方法:dequeue()
语法:arrayQueue.dequeue()
参数:无
描述:移除队列头部的元素,同时返回被移除的元素
返回队首元素
方法:front()
语法:arrayQueue.front()
参数:无
描述:仅仅返回队列的第一个元素
队列是否为空
方法:isEmpty()
语法:arrayQueue.isEmpty()
参数:无
描述:如果队列中没有任何元素则返回true,否则返回false
清空队列
方法:clear()
语法:arrayQueue.clear()
参数:无
描述:移除队列中的所有元素
返回队列的长度
方法:size()
语法:arrayQueue.size()
参数:无
描述:返回队列中元素的个数
输出队列
方法:show()
语法:arrayQueue.show()
参数:无
描述:返回队列中的所有元素
代码实现
通过动态原型模式创建队列类型
队列类跟栈类非常类似,唯一的区别就是的出队与退栈的方法不同。
function Queue() {
this.items = [];
//初始化队列方法
if (typeof Queue.prototype.push != "function") {
//入队
Queue.prototype.enqueue = function() {
var len = arguments.length;
if (len == 0) {
return;
}
for (var i = 0; i < len; i++) {
this.items.push(arguments[i])
}
}
//出队
Queue.prototype.dequeue = function() {
var result = this.items.shift();
return typeof result != 'undefined' ? result : false;
}
//返回队首元素
Queue.prototype.front = function() {
return this.items[items.length - 1];
}
//队列是否为空
Queue.prototype.isEmpty = function() {
return this.items.length == 0;
}
//返回队列长度
Queue.prototype.size = function() {
return this.items.length;
}
//清空队列
Queue.prototype.clear = function() {
this.items = [];
}
//返回队列
Queue.prototype.show = function() {
return this.items;
}
}
}
优先队列
优先队列是队列的修改版。元素的添加与移除是基于优先级别进行的。
通过寄生组合式继承队列,并为子类添加独有的方法实现优先队列。
//继承父类原型
function inheritPrototype(superTyep, subType) {
//创建寄生式继承
function inherit(p) {
if (p == null) throw TypeError(); //首先判断输入的参数是不是为空,为空则抛出异常
if (Object.create) { //判断当前浏览器支不支持Object.create方法,不支持则手写
return Object.create(p);
}
var t = typeof p; //进一步检测
if (t !== 'object' && t !== 'function') {
throw TypeError();
}
function f() {} //定义一个空构造函数
f.prototype = p; //将其原型属性设置为p
return new f(); //使用f()创建p的继承对象
}
//实现父类原型的继承
var prototype = inherit(superTyep.prototype);
prototype.constructor = subType;
subType.prototype = prototype;
}
实现寄生组合式继承
//利用寄生组合式继承队列类型
//优先队列
function priorityQueue() {
//继承父类的实例属性
Queue.call(this);
//创建队列元素
function QueueElement(element, priority) {
this.element = element;
this.priority = (priority==0||priority) ? priority : 4; //默认级别为4
}
//修改(覆盖)父类方法
this.enqueue = function (element, priority) {
var queueElement = new QueueElement(element, priority);
//设置优先级分级
function pri(pri) {
//分级最多10级
//分级可以是数字0到9,也可以是字母A-J或小写字母a-j
var ma =pri+"",
num = /^[0-9]$/,
str = /^[A-J]$|^[a-j]$/;
//判断是否符合条件
if (!ma.match(num) && !ma.match(str)) {
throw new TypeError("分级必须是数字0-9或者是字母A-J(a-j)");
} else if (ma.match(num)) {
return true;
} else {
//要将字母转化成数字
switch (true) {
case /A/i.test(ma):
queueElement.priority = 0;
break;
case /B/i.test(ma):
queueElement.priority = 1;
break;
case /C/i.test(ma):
queueElement.priority = 2;
break;
case /D/i.test(ma):
queueElement.priority = 3;
break;
case /E/i.test(ma):
queueElement.priority = 4;
break;
case /F/i.test(ma):
queueElement.priority = 5;
break;
case /G/i.test(ma):
queueElement.priority = 6;
break;
case /H/i.test(ma):
queueElement.priority = 7;
break;
case /I/i.test(ma):
queueElement.priority = 8;
break;
case /J/i.test(ma):
queueElement.priority = 9;
break;
default:
throw new TypeError("设置级别错误。");
break;
}
return true;
}
}
//分级成功才能进入队列
//队列为空直接添加元素
if ( this.isEmpty()&&pri(queueElement.priority)) {
this.items.push(queueElement);
} else if (pri(queueElement.priority)) {
var added = false,
_items=this.items;
for (var i = 0; i < _items.length; i++) {
//级别高的放到前面
if (queueElement.priority <_items[i].priority) {
_items.splice(i, 0, queueElement);
added = true;
break;
}
}
//级别最低放最后
if (!added) {
this.items.push(queueElement)
}
}
}
}
//继承父类原型
inheritPrototype(Queue, priorityQueue);
调用
var ss = new priorityQueue();
ss.enqueue("a", 1);
ss.enqueue("b", 3);
ss.enqueue("c", 2);
ss.enqueue("d", "a");
console.log(ss.show());
成功按照级别入队:
出队
ss.dequeue();
成功出队: