用javascript封装队列数据结构，优先队列实现，击鼓传花

1.队列数据结构

	1.队列是一种受限的线性表，特点先进先出(FIFO)
	2.受限之处在于它只允许在表的前端进行删除操作，
	  在表的后端进行插入。
	3.队列的实现：基于数组实现，基于链表实现

队列的常见操作:

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

• dequeue () : 移除队列的第一项(即排在队列嘴前面的)项，并返回被移除的元素

• front () : 返回队列中第一个元素——最先被添加，也将是最先被移除的元素，队列不做任何变动

  (不移除元素，只返回元素信息与Stack类的peek方法非常类似)

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

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

• toString( )：将队列中的内容，转成字符串形式

2.封装队列

     // 封装一个队列
        function Queue(){
            // 属性
            this.items = [];
            // 方法
            // 可以向队列中添加一个或多个值
            Queue.prototype.enqueue = function(...rest){
                this.items.push(...rest);
            };
            Queue.prototype.dequeue = function(){
                return this.items.shift();
            };
            Queue.prototype.front = function(){
                return this.items[0];
            };
            Queue.prototype.isEmpty = function(){
                return this.items.length === 0;
            };
            Queue.prototype.size = function(){
                return this.items.length;
            };
            Queue.prototype.toString = function(){
                    let result = '';
                    this.items.forEach((item,index)=>{
                        result += item + ' ';
                    })
                    return result;
            }
        }

        let myQueue = new Queue();
        myQueue.enqueue(1,2,3,4,5);
        console.log(myQueue);
        myQueue.dequeue();
        console.log(myQueue.size());
        console.log(myQueue.front());
        console.log(myQueue.isEmpty());
        console.log(myQueue.toString());

3.使用ES6封装队列

 // ES6封装一个队列
        class Queue{
            constructor(){
                this.items = {};
                this.count = 0;  //记录队列的总长度
                this.firstCount = 0; //记录队列的首个元素
            }

            enqueue(...rest){
                if(rest.length == 0)  return;
                rest.forEach(item=>{
                    this.items[this.count] = item;
                    this.count++;
                })
            };
            dequeue(){
                if(this.isEmpty())  return null;
                const result = this.items[this.firstCount];
                delete this.items[this.firstCount];
                this.firstCount++;
                return result;
            };
            front(){
                 return  this.items[this.firstCount];
            };
            isEmpty(){
                    return this.size() == 0 ;
            };
            size(){
               return  this.count - this.firstCount;
            };
            toString(){
                let element = this.items[this.firstCount];
              for(var i=this.firstCount+1;i<this.count;i++){
                    element = ` ${element}  ${this.items[i]}`;
              }
              return element;
            }
        }

        let myQueue = new Queue();
        myQueue.enqueue(1,2,3,4,5);
        console.log(myQueue.front());
        console.log(myQueue.dequeue());
        console.log(myQueue.front());
        console.log(myQueue.size());
        console.log(myQueue.toString());
        console.log(myQueue);

4.优先队列

   function PriorityQueue(){
            
            // 内部类，在类里面在封装一个类，表示带优先级的数据
            function QueueElement(element,priority){
                this.element = element;
                this.priority = priority
            }

            // 封装属性
            this.items = [];

            // 1.按照优先级插入方法
            PriorityQueue.prototype.enqueue = function(element,priority){
                // 创建QueueElement对象
                let queueElement = new QueueElement(element,priority);

                // 判断队列是否为空
                if(this.items.length == 0){
                    this.items.push(queueElement);
                }else{
                    // 定义一个变量记录是否添加了新元素
                    let added = false;
                   for(let i in this.items){
                         // 让新插入的元素与原有元素进行优先级比较(priority越小，优先级越大)
                         if(queueElement.priority < this.items[i].priority){
                            this.items.splice(i,0,queueElement);
                            added = true;
                            return;
                            // 新元素已经找到插入位置了，可以使用break停止循环
                        }
                    }
                  

                    // 新元素没有成功插入，就把它放在队列的最前面
                    if(!added){
                        this.items.push(queueElement);
                    }
                }

            }

            // 2.dequeue() ：从队列中删除前端元素
            PriorityQueue.prototype.dequeue = function(){
                return this.items.shift();
            }
            // 3.front()：查看队列第一个元素
            PriorityQueue.prototype.front = function(){
                return this.items[0];
            }
            // 4.isEmpty()查看队列是否为空
            PriorityQueue.prototype.isEmpty = function(){
                return this.items.length === 0;
            }
            // 5.size()查看队列是否为空
            PriorityQueue.prototype.size = function(){
                return this.items.length;
            }

            PriorityQueue.prototype.toString = function(){
                let result = '';
                for(let i of this.items){
                    result += i.element + '-' + i.priority + ' ';
                }
                return result;
            }

        }

        let Queue = new PriorityQueue();
        Queue.enqueue('Vue',10);
        Queue.enqueue('React',1);
        Queue.enqueue('angular',100);
        Queue.enqueue('jquery',20);
        Queue.enqueue('jquery',2);
        console.log(Queue);
        Queue.dequeue();
        console.log(Queue.front());
        console.log(Queue.isEmpty());
        console.log(Queue.size());
        console.log(Queue.toString());

5.队列的应用-击鼓传花

 function Queue(){
            // 属性
            this.items = [];

            // 方法
            Queue.prototype.enqueue = function (...rest){
               this.items.push(...rest);
            };

            Queue.prototype.dequeue = function(){
                if(this.isEmpty()){
                    return null;
                }
                return this.items.shift();
            };

            Queue.prototype.front = function (){
                return this.items[0];
            }

            Queue.prototype.size = function(){
                return this.items.length;
            }

            Queue.prototype.isEmpty =  function (){
                return this.items.length === 0;
            }

            Queue.prototype.toString = function(){
                let result = '';
                for(var i of this.items){
                    result += i + ' '; 
                }
                return result;
            }
        }
   
        // 实现击鼓传花
        let passGame = (nameList,num) =>{
            // 1.创建队列
            let queue = new Queue();
            // 2.将人加入队列
            queue.enqueue(...nameList);
            // 3.开始数数
            while(queue.size() > 1){  //队列中只剩一个人就停止数数
                // 不是num，重新加入队列末尾
                // 是num的时候，将其从队列中删除
                for(var i=0; i<num-1;i++){
                    queue.enqueue(queue.dequeue());
                }
                queue.dequeue();
            }

            // 获取剩下的那个人
            console.log(queue.size());
            let lastName =  queue.front();
            console.log('最后剩下的那个人',lastName);
            return nameList.indexOf(lastName);
        }

        let names = ['Tom','jack','lili','Tony','lucy'];
        console.log(passGame(names,3));