# Queues: Data Structures & Algorithms in JavaScript P.3

I’m learning about data structures and algorithms in JavaScript. I’m using various online resources and going to be sharing my notes as a series of blog posts. The topics are below:

**Data Structures**: List ADT | Stacks | Queues | Linked Lists | Trees, Tries & Graphs | Heaps | Hash Tables**Algorithms**: Breadth-First Search | Depth-First Search | Binary Search | Merge Sort | Quick Sort**Concepts**: Memory (Stack vs. Heap) | Recursion | Big O Time & Space

### 3. Queues

- A queue is a list of elements where elements are inserted to the back of the list but removed from the front of the list.
- As such, a queue is referred to as a First-in, First-out (FIFO) data structure.
- It is efficient and fast because we can add or remove data at a constant time operation.
- The
operation adds an element to the back of the queue, while**enqueue****dequeue**removes an element from the front of a queue. - The
method**peek**returns the value of the element at the front of the queue without removing it as**dequeue**does. - The
method checks to see if the queue is empty, while the**isEmpty**is an array used to store data internally.**dataStore** - Eg. usage of queue data structure: the Event-loop of a web browser.
- Here is an implementation of a Queue class:

An example using the Queue class::

### Priority Queue:

- A priority queue is a queue where elements are removed from the queue based on a priority constraint instead of the default FIFO principle.
- For instance the Emergency Department at a hospital might implement a priority queue. The hospital would then tend to patients not only on a first come first served basis(fifo) but also by assigning patients a priority code based on the severity of their emergency.

### Implementing a Queue using only a Stack

- More on Stacks
- A Stack is a Last in, First out data structure.
- Using two Stacks we can implement a Queue data structure.
- We push new elements on to a first stack. Then, to reverse the order of the stack we can pop all its elements out and push them to a second stack.
- Now that the order of the first stack is reversed inside the second stack, we can start poping from the second stack.
- This way First in inside the first stack becomes First Out from the second stack ( aka Queue!)

Here is an implementation of a Queue using two Stacks:

### Implementing a Stack using only a Queue

- As stated before, a queue is a First in, First out data structure.
- Using two Queues we can implement a Stack. (More on Stacks)
- First we simply push new elements to the first queue.
- When we pop however, we enqueue a second queue with the all the elements of the first queue except for the last element.
- The remaining last element from the first queue is then returned as the poped element.
- We then reassign first queue to be equal to the second queue(now with out the poped element).
- This way First in (last remaining element in the first queue) becomes First Out ( aka a Stack!)

Here is an implementation of a Stack using two Queues: