denque

What is denque?

The denque npm package is a fast double-ended queue implementation. It is optimized for performance and is useful for situations where you need a queue that allows adding or removing items from both ends.

What are denque's main functionalities?

Adding items

This demonstrates how to add items to the queue. 'push' adds an item to the end of the queue, while 'unshift' adds an item to the beginning.

const Denque = require('denque');
let myQueue = new Denque();
myQueue.push('item1');
myQueue.unshift('item0');

Removing items

This shows how to remove items from the queue. 'pop' removes an item from the end of the queue, and 'shift' removes an item from the beginning.

const removedLast = myQueue.pop();
const removedFirst = myQueue.shift();

Peeking at items

This code sample demonstrates how to peek at items in the queue without removing them. 'peekFront' looks at the first item, and 'peekBack' looks at the last item.

const firstItem = myQueue.peekFront();
const lastItem = myQueue.peekBack();

Other packages similar to denque

fastqueue

FastQueue is another high-performance queue implementation. It offers similar functionality to Denque but may have different performance characteristics under certain conditions.

double-ended-queue

This package also provides a double-ended queue implementation. It is similar to Denque in terms of API and functionality but might have slight differences in performance or additional methods.

README

DENQUE

Extremely fast and lightweight double-ended queue implementation with zero dependencies.

Double-ended queues can also be used as a:

• Stack
• Queue

This implementation is currently the fastest available, even faster than double-ended-queue, see the benchmarks

Every queue operation is done at a constant O(1) - including random access from .peekAt(index).

Requires Node.js v4+, io.js v3+ or any platform supporting ES6 classes (pretty much all browsers).

Quick Start

npm install denque

const Denque = require("denque");

const denque = new Denque([1,2,3,4]);
denque.shift(); // 1
denque.pop(); // 4

API

• new Denque()
• new Denque(Array items)
• push(item)
• unshift(item)
• pop()
• shift()
• toArray()
• peekBack()
• peekFront()
• peekAt(int index)
• isEmpty()
• clear()

#####new Denque() -> Denque

Creates an empty double-ended queue with initial capacity of 4.

var denque = new Denque();
denque.push(1, 2, 3);
denque.shift(); //1
denque.pop(); //3

#####new Denque(Array items) -> Denque

Creates a double-ended queue from items.

var denque = new Denque([1,2,3,4]);
denque.shift(); // 1
denque.pop(); // 4

#####push(item) -> int

Push an item to the back of this queue. Returns the amount of items currently in the queue after the operation.

var denque = new Denque();
denque.push(1);
denque.pop(); // 1
denque.push(2);
denque.push(3);
denque.shift(); // 2
denque.shift(); // 3

#####unshift(item) -> int

Unshift an item to the front of this queue. Returns the amount of items currently in the queue after the operation.

var denque = new Denque([2,3]);
denque.unshift(1);
denque.toString(); // "1,2,3"
denque.unshift(-2);
denque.toString(); // "-2,-1,0,1,2,3"

#####pop() -> dynamic

Pop off the item at the back of this queue.

Note: The item will be removed from the queue. If you simply want to see what's at the back of the queue use peekBack() or .peekAt(-1).

If the queue is empty, undefined is returned. If you need to differentiate between undefined values in the queue and pop() return value - check the queue .length before popping.

var denque = new Denque([1,2,3]);
denque.pop(); // 3
denque.pop(); // 2
denque.pop(); // 1
denque.pop(); // undefined

Aliases: removeBack

#####shift() -> dynamic

Shifts off the item at the front of this queue.

Note: The item will be removed from the queue. If you simply want to see what's at the front of the queue use peekFront() or .peekAt(0).

If the queue is empty, undefined is returned. If you need to differentiate between undefined values in the queue and shift() return value - check the queue .length before shifting.

var denque = new Denque([1,2,3]);
denque.shift(); // 1
denque.shift(); // 2
denque.shift(); // 3
denque.shift(); // undefined

#####toArray() -> Array

Returns the items in the queue as an array. Starting from the item in the front of the queue and ending to the item at the back of the queue.

var denque = new Denque([1,2,3]);
denque.push(4);
denque.unshift(0);
denque.toArray(); // [0,1,2,3,4]

#####peekBack() -> dynamic

Returns the item that is at the back of this queue without removing it.

If the queue is empty, undefined is returned.

var denque = new Denque([1,2,3]);
denque.push(4);
denque.peekBack(); // 4

#####peekFront() -> dynamic

Returns the item that is at the front of this queue without removing it.

If the queue is empty, undefined is returned.

var denque = new Denque([1,2,3]);
denque.push(4);
denque.peekFront(); // 1

#####peekAt(int index) -> dynamic

Returns the item that is at the given index of this queue without removing it.

The index is zero-based, so .peekAt(0) will return the item that is at the front, .peekAt(1) will return the item that comes after and so on.

The index can be negative to read items at the back of the queue. .peekAt(-1) returns the item that is at the back of the queue, .peekAt(-2) will return the item that comes before and so on.

Returns undefined if index is not a valid index into the queue.

var denque = new Denque([1,2,3]);
denque.peekAt(0); //1
denque.peekAt(1); //2
denque.peekAt(2); //3

denque.peekAt(-1); // 3
denque.peekAt(-2); // 2
denque.peekAt(-3); // 1

Note: The implementation has O(1) random access using .peekAt().

Aliases: get

#####isEmpty() -> boolean

Return true if this queue is empty, false otherwise.

var denque = new Denque();
denque.isEmpty(); // true
denque.push(1);
denque.isEmpty(); // false

#####clear() -> void

Remove all items from this queue. Does not change the queue's capacity.

var denque = new Denque([1,2,3]);
denque.toString(); // "1,2,3"
denque.clear();
denque.toString(); // ""

Benchmarks

1000 items in queue

denque x 31,015,027 ops/sec ±1.52% (86 runs sampled)
double-ended-queue x 21,350,509 ops/sec ±1.21% (86 runs sampled)

2 million items in queue

denque x 28,710,051 ops/sec ±0.95% (87 runs sampled)
double-ended-queue x 20,531,490 ops/sec ±1.04% (89 runs sampled)