用js写出数据结构中的自定义队列，利用队列思想写出一个击鼓传花的游戏函数，优先级队列

 队列的核心是先进先出

1.用js写出数据结构中的自定义队列

        class Queue{
            constructor(){
                this.item = [];
            }

            // 1.入队
            enqueue(ele){
                this.item.push(ele)
            }
            // 2.出队
            delqueue(){
                return this.item.shift()
            }
            // 3.返回队首元素
            front(){
                return this.item[0]
            }
            // 4.判空
            isEmpty(){
                return this.item.length == 0
            }
            // 5.队列元素的个数
            size(){
                return this.item.length
            }
        }

        let queue = new Queue();

        for (let i = 0; i < 5; i++) {
           queue.enqueue(i)  //入队5个元素
        }

        console.log(queue.delqueue());//出队
        console.log(queue.delqueue());
        console.log(queue.delqueue());
        console.log(queue.front()); //队首元素
        console.log(queue.isEmpty()); //判空
        console.log(queue.size()); //队中的元素个数
        console.log(queue.item); 

打印的结果为

 2.利用队列思想写出一个击鼓传花的游戏函数

即一群人围成一圈，将一束花依次传递，每当花被传递了三次时，则会将第三次传递花的人淘汰，直到剩下最后一人。

以下代码将引用上边的写的class类Queue函数

   function jigu(arr) {

            // 创建队列
            let queue = new Queue();

            // 1.依次入队
            arr.forEach(ele => {
                queue.enqueue(ele)
            });

            // 2.数数
            let count = 1;
            while (queue.size() > 1) { //队列中只有一个元素停止数数
                if (count < 3) {
                    let node = queue.delqueue(); //先出队
                    queue.enqueue(node); //在入队
                    count++;
                } else {
                    queue.delqueue(); // 直接出队
                    count = 1
                }
            }
            // 获胜者和在原数组中的位置
            return {
                winner: queue.front(), 
                position: arr.indexOf(queue.front())
            }
        }
        var arr = ["曜", "瑶", "镜", "澜", "暃", "铠"];//五人先后顺序
        console.log(jigu(arr));

结果为

 3.优先级队列的入队

        class Node {
            constructor(ele, pro) { 
                this.data = ele; //入队的节点值
                this.priority = pro //入队的节点优先级
            }
        }
        class PriorityQueue {  
            constructor() {
                this.items = []; //创建一个空数组来装优先级队列
            }

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

                if (this.items.length == 0) { 
                    this.items.push(newnode)  // 如果为空队列则直接入队
                } else { //非空队列

                    let isAdd = false; //设置一个开关，判断元素是否被添加到队列中

                    for (let i = 0; i < this.items.length; i++) { //依次比较数组队列中元素的优先级

                        if (newnode.priority < this.items[i].priority) { //新节点的优先级小于队列中元素的优先级（越小优先级越高）
                            this.items.splice(i, 0, newnode);//将从原数组组中的i位置开始删除0个节点，并将新节点插入到队列中
                            isAdd = true;
                            break; //终止for循环
                        }
                    }

                    // 循环遍历结束都没有比新节点要小的元素（优先级最小或者等于原数组中最小的优先级）,直接添加到队列的最后
                    if(!isAdd){
                        this.items.push(newnode)
                    }
                }
            }
        }
        let  priority= new PriorityQueue()
        priority.enqueue("hello", 100);
        priority.enqueue("ab", 10);
        priority.enqueue("world", 100);
        priority.enqueue("helo88888", 2);
        priority.enqueue("6666666666666", 2);
        console.log(priority.items);

打印结果：