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 enqueue operation adds an element to the back of the queue, while dequeue removes an element from the front of a queue.
• The peek method returns the value of the element at the front of the queue without removing it as dequeue does.
• The isEmpty method checks to see if the queue is empty, while the dataStore is an array used to store data internally.
• 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:

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.