Before we begin understanding queues, let's quickly take a look at the types of queues that we may want to use in our applications:

• Simple queue: In a simple FIFO queue, the order is retained and data leaves in the same order in which it comes in
• Priority queue: A queue in which the elements are given a predefined priority
• Circular queue: Similar to a simple queue, except that the back of the queue is followed by the front of the queue
• Double ended queue (Dequeue): Similar to the simple queue but can add or remove elements from either the front or the back of the queue

Implementing an API is never as easy as it seems, as discussed earlier. When making generic classes, we can never predict what kinds of a situation our queue is going to be used in. With that in mind, let's create a very generic API for our queue and expand it in future as we see fit. Some of the most common operations that we can add to the queue are as follows:

•  add(): Pushes an item to the back of the queue
•  remove(): Removes an item from the start of the queue
•  peek(): Shows the last item added to the queue
•  front(): Returns the item at the front of the queue
•  clear(): Empties the queue
•  size(): Gets the current size of the queue

Of the four types of the queue that we have discussed earlier, first, we will implement a simple queue and then move on to modify it for each type of the subsequent queue.

Similar to a stack, we will create a queue using the following steps:

1. Define a constructor():

class Queue {
    constructor() {
    
    }
}

2. We will be using WeakMap() for in-memory data storage just like we did for stacks: 

    const qKey = {};
    const items = new WeakMap();

    class Queue {
        constructor() {
            
        }
    }

3. Implement the methods described previously in the API:

var Queue = (() => {
    const qKey = {};
    const items = new WeakMap();

    class Queue {

        constructor() {
 ...

Before we start off with use cases, we will need a base starting point in the form of a Node.js application. To create one, ensure that you have the latest Node.js installed:

node -v

This should show you your currently installed Node.js version; if it does not, then download and install the latest version of Node.js from https://nodejs.org/en.

To start off a sample Node.js project, simply create a project folder first and then run the following command from that folder:

npm init

On running this command, Node will prompt you with a series of questions, which you can either fill or leave blank:

Once the blank application is created, all you see is a file called...

Earlier, we saw how we can simply swap out a simple queue for a priority queue and not worry about the functional change that it might cause; similarly, we can swap out priority queues for a higher-performant variant of them: circular dequeues.

Before we start working on a comparison, we will need to discuss circular queues and why we need them. 

The difference between a circular queue and a simple queue is that the back of the queue is followed by the front of the queue. That being said, they are not functionally different. They still perform the same operations, and produce the same results; you might be wondering where exactly they differ and what's the point if the end result is the same.

In JavaScript arrays, memory locations are contiguous. So, when creating a queue and performing operations such as remove(), we will need to worry about...

With that, we conclude this chapter on queues. We learned about simple, priority, and circular queues and it's double-ended variant. We also learned when to apply them based on use cases and we saw with example, how we can leverage the power of benchmarking any algorithm or data structure as needed. In the next chapter, we will be putting sets, maps, and hashes under the microscope to understand their internal workings and see what situations they can be useful in.