@datastructures-js/queue

A performant queue implementation in javascript.

Contents

• Install
• require
• import
• API
  • constructor
  • Queue.fromArray
  • enqueue (push)
  • front
  • back
  • dequeue (pop)
  • isEmpty
  • size
  • clone
  • toArray
  • clear
• Build
• License

Install

1npm install --save @datastructures-js/queue

require

1const { Queue } = require('@datastructures-js/queue');

import

1import { Queue } from '@datastructures-js/queue';

API

constructor

JS

1// empty queue
2const queue = new Queue();
3
4// from an array
5const queue = new Queue([1, 2, 3]);

TS

1// empty queue
2const queue = new Queue<number>();
3
4// from an array
5const queue = new Queue<number>([1, 2, 3]);

Queue.fromArray

JS

1// empty queue
2const queue = Queue.fromArray([]);
3
4// with elements
5const list = [10, 3, 8, 40, 1];
6const queue = Queue.fromArray(list);
7
8// If the list should not be mutated, use a copy of it.
9const queue = Queue.fromArray(list.slice());

TS

1// empty queue
2const queue = Queue.fromArray<number>([]);
3
4// with elements
5const list = [10, 3, 8, 40, 1];
6const queue = Queue.fromArray<number>(list);

enqueue (push)

adds an element to the back of the queue.

1queue.enqueue(10).enqueue(20); // or queue.push(123)

front

peeks on the front element of the queue.

1console.log(queue.front()); // 10

back

peeks on the back element in the queue.

1console.log(queue.back()); // 20

dequeue (pop)

removes and returns the front element of the queue in O(1) runtime.

1console.log(queue.dequeue()); // 10 // or queue.pop()
2console.log(queue.front()); // 20

Dequeuing all elements takes O(n) instead of O(n²) when using shift/unshift with arrays.

Explanation by @alexypdu:

Internally, when half the elements have been dequeued, we will resize the dynamic array using Array.slice() which runs in $O(n)$. Since dequeuing all $n$ elements will resize the array $\log_2n$ times, the complexity is $$1 + 2 + 4 + \cdots + 2^{\log_2 n - 1} = 2 ^ {(\log_2 n - 1) + 1} - 1 = n - 1 = O(n)$$ Hence the overall complexity of dequeuing all elements is $O(n + n) = O(n)$, and the amortized complexity of dequeue() is thus $O(1)$.

benchmark:

dequeuing 1 million elements in Node v14

Queue.dequeue	Array.shift
~27 ms	~4 mins 31 secs

isEmpty

checks if the queue is empty.

1console.log(queue.isEmpty()); // false

size

returns the number of elements in the queue.

1console.log(queue.size()); // 1

clone

creates a shallow copy of the queue.

1const queue = Queue.fromArray([{ id: 2 }, { id: 4 } , { id: 8 }]);
2const clone =  queue.clone();
3
4clone.dequeue();
5
6console.log(queue.front()); // { id: 2 }
7console.log(clone.front()); // { id: 4 }

toArray

returns a copy of the remaining elements as an array.

1queue.enqueue(4).enqueue(2);
2console.log(queue.toArray()); // [20, 4, 2]

clear

clears all elements from the queue.

1queue.clear();
2queue.size(); // 0

Build

1grunt build

License

The MIT License. Full License is here