什么是队列？

队列(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out)

• 队列是一种受限的线性结构

• 受限之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作

实现队列

创建

function Queue(){

}

队列的操作

• enqueue(element)：向队列尾部添加一个（或多个）新的项。

• dequeue()：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。

• front()：返回队列中第一个元素——最先被添加，也将是最先被移除的元素。队列不做任何变动（不移除元素，只返回元素信息——与Stack类的peek方法非常类似）。

• isEmpty()：如果队列中不包含任何元素，返回true，否则返回false。

• size()：返回队列包含的元素个数，与数组的length属性类似。

封装队列的基本方法

// 封装队列方法
        class Queue {
            constructor() {
                this.item = []
            }
            size() {
                return this.item.length
            }
            enqueue = function (el) {
                this.item.push(el)
            }
            delqueue() {
                return this.item.shift()
            }
            front() {
                return this.item[0]
            }
            isEmpty() {
                return this.item.length == 0
            }
        }

// 操作队列
        var item =["hello","world","!"]
        let queue = new Queue()
        queue.enqueue(item)
        queue.enqueue("xxk")
        queue.enqueue("danny")

        queue.delqueue()
        console.log(queue.front())
        console.log(queue.isEmpty());
        console.log(queue.size());
        console.log(queue);

优先级队列的实现

// 优先级队列
        // 方法，传入ele：元素 pro：优先级
        class Node {
            constructor(ele, pro) {
                this.data = ele;
                this.priority = pro
            }
        }
        // 封装一个类PriorityQueue
        class PriorityQueue {
            constructor() {
                this.item = [];
            }

            enqueue(ele, priority) {
                // 创建新节点   或者let newnode = {data:ele,priority:priority}
                let newnode = new Node(ele, priority);

                if (this.item.length == 0) { 
                    // 如果是空队列，把node中参数ele priority传入函数
                    this.item.push(newnode)
                } else { //非空队列

                    let isAdd = false; //元素是否被添加到队列中

                    for (let i = 0; i < this.item.length; i++) { //依次比较优先级

                        if (newnode.priority < this.item[i].priority) { //新节点的优先级小于队列中元素的优先级
                            this.item.splice(i, 0, newnode);//将新节点插入到队列中
                            isAdd = true;
                            break;
                        }
                    }

                    // 循环遍历结束都没有比新节点要小的元素,直接添加到队列的最后
                    if (!isAdd) {
                        this.item.push(newnode)
                    }
                }
            }
        }
        let pq = new PriorityQueue()