js数据结构与算法之队列结构

一、队列（Queue）
指：一种受限的线性表，先进先出（FIFO）。
受限之处：它只允许在表的前端进行删除操作，而表的后端进行插入操作。

二、队列的应用

1. 打印队列
   有五份文档需要打印, 这些文档会按照次序放入到打印队列中。
   打印机会依次从队列中取出文档, 优先放入的文档, 优先被取出, 并且对该文档进行打印。
   以此类推, 直到队列中不再有新的文档。

2. 线程队列
   在开发中, 为了让任务可以并行处理，通常会开启多个线程。但是我们不能让大量的线程同时运行处理任务，占用过多的资源 。
   这个时候如果有需要开启线程处理任务的情况, 我们就会使用线程队列 。线程队列会依照次序来启动线程, 并且处理对应的任务。

三、队列的常见操作
enqueue(element): 向队列尾部添加一个(或多个) 新的项。
dequeue(): 移除队列的第一(即排在队列最前面的) 项, 并返回被移除的元素。
front(): 返回队列中第一个元素——最先被添加, 也将是最先被移除的元素。 队列不做任何变动(不移除元素 只返回元素信息—— 与 Stack类的peek方法非常类似)。
isEmpty(): 如果队列中不包含任何元素, 返回true, 否则返回 false。
size(): 返回队列包含的元素个数, 与数组的length属性类似。
toString(): 将队列中的内容, 转成字符串形式。

四、队列类的创建

	// 封装队列类
    function Queue() {
      // 属性
      this.items = [];

      // 方法
      // 1. 将元素加入到队列中
      Queue.prototype.enqueue = function (element) {
        this.items.push(element);
      }
      // 2. 从队列中删除前端元素
      Queue.prototype.dequeue = function () {
        return this.items.shift();
      }
      // 3. 查看前端元素
      Queue.prototype.front = function () {
        return this.items[0];
      }
      // 4. 查看队列是否为空
      Queue.prototype.isEmpty = function () {
        return this.items.length == 0;
      }
      // 5. 查看队列中元素的个数
      Queue.prototype.size = function () {
        return this.items.length;
      }
      // 6. toString()方法
      Queue.prototype.toString = function () {
        let resultString = ''
        for (let i = 0; i < this.items.length; i++) {
          resultString += this.items[i] + ' '
        };
        return resultString;
      }
    }
    // 使用队列
    const queue = new Queue();
    // 将元素加入到队列中
    queue.enqueue('abc');
    queue.enqueue('cba');
    queue.enqueue('nba');
    queue.enqueue('mba');

    alert(queue); // abc cba nba mba 

    // 从队列中删除元素
    queue.dequeue();
    alert(queue); // cba nba mba 
    queue.dequeue();
    alert(queue); // nba mba 

    // front方法
    alert(queue.front()); // nba 

    // 验证其他方法
    alert(queue.isEmpty()); // false
    alert(queue.size()); // 2 ---> nba mba

五、击鼓传花

// 封装队列类
function Queue() {
  // 属性
  this.items = [];

  // 方法
  // 1. 将元素加入到队列中
  Queue.prototype.enqueue = function (element) {
    this.items.push(element);
  }
  // 2. 从队列中删除前端元素
  Queue.prototype.dequeue = function () {
    return this.items.shift();
  }
  // 3. 查看前端元素
  Queue.prototype.front = function () {
    return this.items[0];
  }
  // 4. 查看队列是否为空
  Queue.prototype.isEmpty = function () {
    return this.items.length == 0;
  }
  // 5. 查看队列中元素的个数
  Queue.prototype.size = function () {
    return this.items.length;
  }
  // 6. toString()方法
  Queue.prototype.toString = function () {
    let resultString = ''
    for (let i = 0; i < this.items.length; i++) {
      resultString += this.items[i] + ' '
    };
    return resultString;
  }
}
function passGame(nameList, num) {
  // 1. 创建一个队列结构
  let queue = new Queue();

  // 2. 将所有人依次加入到队列中
  for (let i = 0; i < nameList.length; i++) {
    queue.enqueue(nameList[i]);
  }

  // 3. 开始数数字
  while (queue.size() > 1) {
    // （1）num数字之前的人，重新放入到队列的末尾
    for (let i = 0; i < num - 1; i++) {
      queue.enqueue(queue.dequeue());
    }
    // （2）num对应的这个人，直接从队列中删除
    queue.dequeue();
  }

  // 4. 获取剩下的那个人
  alert(queue.size()); // 1
  const endName = queue.front();
  alert('最终剩下的人' + endName); // hh

  return nameList.indexOf(endName); // 3
}

// 测试击鼓传花
names = ['ll', 'kk', 'jj', 'hh', 'gg'];
alert(passGame(names, 3));

六、优先级队列

1. 特点：
   优先级队列在插入一个元素的时候会考虑该数据的优先级
   和其他数据优先级进行比较，比较完成后，可以得出这个元素在队列中的正确的位置
   其他处理方式与基本队列的处理方式一样

2. 优先级队列的应用
   现实的例子：
   （1）机场登机的顺序
   头等舱和商务舱乘客的优先级要高于经济舱乘客。
   在有些国家, 老年人和孕妇(或带小孩的妇女) 登机时也享有高于其他乘客的优先级。
   （2）医院的(急诊科) 候诊室
   医生会优先处理病情比较严重的患者
   当然一般情况下是按照排号的顺序。

   计算机中：
   比如每个线程处理的任务重要性不同, 我们可以通过优先级的大小来决定该线程在队列中被处理的次序

	// 封装优先级队列
    function PriorityQueue() {
      // 1. 创建内部类,表示带优先级的数据
      function QueueElement(element, priority) {
        this.element = element;
        this.priority = priority;
      }

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

      // 3. 实现插入方法
      PriorityQueue.prototype.enqueue = function (element, priority) {
        // （1）创建QueueElement对象
        const queueElement = new QueueElement(element, priority);

        // （2）判断队列是否为空
        if (this.items.length == 0) {
          this.items.push(queueElement)
        } else {
          // 定义变量记录是否插入新元素
          let added = false;
          for (let i = 0; i < this.items.length; i++) {
            // 新插入的元素与原有元素进行比较（priority越小，优先级越大）
            if (queueElement.priority < this.items[i].priority) {
              this.items.splice(i, 0, queueElement);
              added = true;
              // 新元素找到插入位置后，停止循环
              break;
            }
          }

          // 若没有成功插入，就把它放在队列的最前面
          if (!added) {
            this.items.push(queueElement);
          }
        }
      }
      // 4. 从队列中删除前端元素
      PriorityQueue.prototype.dequeue = function () {
        return this.items.shift();
      }
      // 5. 查看前端元素
      PriorityQueue.prototype.front = function () {
        return this.items[0];
      }
      // 6. 查看队列是否为空
      PriorityQueue.prototype.isEmpty = function () {
        return this.items.length == 0;
      }
      // 7. 查看队列中元素的个数
      PriorityQueue.prototype.size = function () {
        return this.items.length;
      }
      // 8. toString()方法
      PriorityQueue.prototype.toString = function () {
        let resultString = ''
        for (let i = 0; i < this.items.length; i++) {
          resultString += this.items[i].element + '-' + this.items[i].priority + ' ';
        };
        return resultString;
      }
    }

    // 测试代码
    const pq = new PriorityQueue();

    // emqueue方法
    pq.enqueue('lll', 111);
    pq.enqueue('kkk', 10);
    pq.enqueue('jjj', 80);
    pq.enqueue('hhh', 200);
    alert(pq); // kkk-10 jjj-80 lll-111 hhh-200