用Javascript实现队列

在本文中，我们将在javascript中实现Queue数据结构。队列按照FIFO(先进先出)原则工作。因此，它执行两个基本操作，即在队列末尾添加元素和从队列前移元素。像堆栈一样，队列也是线性数据结构。

注意：假设队列可以动态增长，我们不考虑溢出情况
现在，让我们来看一个使用数组的队列类的示例：-

例子：

// Queue class
class Queue
{
    // Array is used to implement a Queue
    constructor()
    {
        this.items = [];
    }
                  
    // Functions to be implemented
    // enqueue(item)
    // dequeue()
    // front()
    // isEmpty()
    // printQueue()
}

与上面的定义一样，我们创建了一个队列类的框架，其中包含一个构造函数，在该构造函数中，我们声明了一个用于实现队列的数组。因此，通过创建队列类的对象，将自动调用此构造方法，并声明该数组

让我们实现以下每个功能：

1. enqueue() –将元素添加到队列中

   // enqueue function
   enqueue(element)
   {    
       // adding element to the queue
       this.items.push(element);
   }
   

   此函数在队列的后面添加一个元素。我们使用array的push()方法在队列末尾添加一个元素。

2. dequeue() –从队列中删除一个元素

   // dequeue function
   dequeue()
   {
       // removing element from the queue
       // returns underflow when called 
       // on empty queue
       if(this.isEmpty())
           return "Underflow";
       return this.items.shift();
   }
   

   此函数从队列的最前面删除一个元素。我们使用数组的shift方法从队列中删除元素。

3. front() –返回队列的前元素

   // front function
   front()
   {
       // returns the Front element of 
       // the queue without removing it.
       if(this.isEmpty())
           return "No elements in Queue";
       return this.items[0];
   }
   

   此函数返回队列的前部元素。我们只需返回数组的第0个元素即可获得队列的开头。

辅助方法

让我们声明一些辅助方法，该方法在处理队列时非常有用。

1. isEmpty() –如果队列为空，则返回true

   // isEmpty function
   isEmpty()
   {
       // return true if the queue is empty.
       return this.items.length == 0;
   }
   

   在此函数，我们使用了数组的length属性，如果数组的长度为0，则队列为空。

2. printQueue() –返回队列的所有元素。

   // printQueue function
   printQueue()
   {
       var str = "";
       for(var i = 0; i < this.items.length; i++)
           str += this.items[i] +" ";
       return str;
   }
   

   在这种方法中，我们串接队列中的所有元素中的一个字符串，返回字符串

注意：根据需要，可以在Queue类中声明不同的helper方法。

执行

现在让我们使用上述的队列类及其不同的方法

// creating object for queue class
var queue = new Queue();
              
  
// Testing dequeue and pop on an empty queue
// returns Underflow
console.log(queue.dequeue());
  
// returns true
console.log(queue.isEmpty());
  
// Adding elements to the queue
// queue contains [10, 20, 30, 40, 50]
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
queue.enqueue(40);
queue.enqueue(50);
queue.enqueue(60);
  
// returns 10
console.log(queue.front());
  
// removes 10 from the queue
// queue contains [20, 30, 40, 50, 60]
console.log(queue.dequeue());
  
// returns 20
console.log(queue.front());
  
// removes 20
// queue contains [30, 40, 50, 60]
console.log(queue.dequeue());
  
// printing the elements of the queue
// prints [30, 40, 50, 60]
console.log(queue.printQueue());

现在，一旦完成Queue类的实现，就可以在不同的应用程序中使用它了。

应用：一种有趣的方法来生成从1到n的二进制数

在此问题中，我们生成从1到n的不同二进制数。

// function to generate binary numbers
function generatePrintBinary(n)
{
    // Create an empty queue of strings
    var q = new Queue();
           
    // Enqueue the first binary number
    q.enqueue("1");
           
    // This loops is like BFS of a tree with 1 as root
    // 0 as left child and 1 as right child and so on
    while(n-- > 0)
    {
        // print the front of queue
        var s1 = q.front();
        q.dequeue();
        console.log(s1);
               
        // Store s1 before changing it
        var s2 = s1;
               
        // Append "0" to s1 and enqueue it
        q.enqueue(s1 + "0");
               
        // Append "1" to s2 and enqueue it. Note that s2 contains
        // the previous front
        q.enqueue(s2 + "1");
     }
}
  
// calling the above function    
// prints [1 10 11 100 101]
generatePrintBinary(5);