Class Deque<E, R>

Deque implemented with circular buckets allowing O(1) amortized push/pop at both ends.

Remarks

Time O(1), Space O(1)

Example

// basic Deque creation and push/pop operations
 // Create a simple Deque with initial values
    const deque = new Deque([1, 2, 3, 4, 5]);

    // Verify the deque maintains insertion order
    console.log([...deque]); // [1, 2, 3, 4, 5];

    // Check length
    console.log(deque.length); // 5;

    // Push to the end
    deque.push(6);
    console.log(deque.length); // 6;

    // Pop from the end
    const last = deque.pop();
    console.log(last); // 6;

Example

// Deque shift and unshift operations
 const deque = new Deque<number>([20, 30, 40]);

    // Unshift adds to the front
    deque.unshift(10);
    console.log([...deque]); // [10, 20, 30, 40];

    // Shift removes from the front (O(1) complexity!)
    const first = deque.shift();
    console.log(first); // 10;

    // Verify remaining elements
    console.log([...deque]); // [20, 30, 40];
    console.log(deque.length); // 3;

Example

// Deque peek at both ends
 const deque = new Deque<number>([10, 20, 30, 40, 50]);

    // Get first element without removing
    const first = deque.at(0);
    console.log(first); // 10;

    // Get last element without removing
    const last = deque.at(deque.length - 1);
    console.log(last); // 50;

    // Length unchanged
    console.log(deque.length); // 5;

Example

// Deque for...of iteration and reverse
 const deque = new Deque<string>(['A', 'B', 'C', 'D']);

    // Iterate forward
    const forward: string[] = [];
    for (const item of deque) {
      forward.push(item);
    }
    console.log(forward); // ['A', 'B', 'C', 'D'];

    // Reverse the deque
    deque.reverse();
    const backward: string[] = [];
    for (const item of deque) {
      backward.push(item);
    }
    console.log(backward); // ['D', 'C', 'B', 'A'];

Example

// Deque as sliding window for stream processing
 interface DataPoint {
      timestamp: number;
      value: number;
      sensor: string;
    }

    // Create a deque-based sliding window for real-time data aggregation
    const windowSize = 3;
    const dataWindow = new Deque<DataPoint>();

    // Simulate incoming sensor data stream
    const incomingData: DataPoint[] = [
      { timestamp: 1000, value: 25.5, sensor: 'temp-01' },
      { timestamp: 1100, value: 26.2, sensor: 'temp-01' },
      { timestamp: 1200, value: 25.8, sensor: 'temp-01' },
      { timestamp: 1300, value: 27.1, sensor: 'temp-01' },
      { timestamp: 1400, value: 26.9, sensor: 'temp-01' }
    ];

    const windowResults: Array<{ avgValue: number; windowSize: number }> = [];

    for (const dataPoint of incomingData) {
      // Add new data to the end
      dataWindow.push(dataPoint);

      // Remove oldest data when window exceeds size (O(1) from front)
      if (dataWindow.length > windowSize) {
        dataWindow.shift();
      }

      // Calculate average of current window
      let sum = 0;
      for (const point of dataWindow) {
        sum += point.value;
      }
      const avg = sum / dataWindow.length;

      windowResults.push({
        avgValue: Math.round(avg * 10) / 10,
        windowSize: dataWindow.length
      });
    }

    // Verify sliding window behavior
    console.log(windowResults.length); // 5;
    console.log(windowResults[0].windowSize); // 1; // First window has 1 element
    console.log(windowResults[2].windowSize); // 3; // Windows are at max size from 3rd onwards
    console.log(windowResults[4].windowSize); // 3; // Last window still has 3 elements
    console.log(dataWindow.length); // 3;

Type Parameters

E = any
R = any
1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.
3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.
4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not

Hierarchy

LinearBase<E, R>
- Deque

Constructors

constructor

new Deque<E, R>(elements?, options?): Deque<E, R>
Create a Deque and optionally bulk-insert elements.
Type Parameters
- E = any
- R = any
Parameters
- Optionalelements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = []
  Iterable (or iterable-like) of elements/records to insert.
- Optionaloptions: DequeOptions<E, R>
  Options such as bucketSize, toElementFn, and maxLen.
Returns Deque<E, R>
New Deque instance.

Remarks
Time O(N), Space O(N)
Overrides LinearBase<E, R>.constructor
- Defined in data-structures/queue/deque.ts:157

Properties

`Protected` `Optional`_toElementFn

_toElementFn?: ((rawElement: R) => E)

The converter used to transform a raw element (R) into a public element (E).

Remarks

Time O(1), Space O(1).

Accessors

bucketCount

get bucketCount(): number
Get the number of buckets allocated.

Returns number
Bucket count.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:250

bucketFirst

get bucketFirst(): number
Get the index of the first bucket in use.

Returns number
Zero-based bucket index.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:202

bucketLast

get bucketLast(): number
Get the index of the last bucket in use.

Returns number
Zero-based bucket index.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:226

buckets

get buckets(): E[][]
Get the internal buckets array.

Returns E[][]
Array of buckets storing values.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:262

bucketSize

get bucketSize(): number
Get the current bucket size.

Returns number
Bucket capacity per bucket.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:190

first

get first(): undefined | E
Get the first element without removing it.

Returns undefined | E
First element or undefined.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:284

firstInBucket

get firstInBucket(): number
Get the index inside the first bucket.

Returns number
Zero-based index within the first bucket.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:214

last

get last(): undefined | E
Get the last element without removing it.

Returns undefined | E
Last element or undefined.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:295

lastInBucket

get lastInBucket(): number
Get the index inside the last bucket.

Returns number
Zero-based index within the last bucket.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:238

length

get length(): number
Get the number of elements in the deque.

Returns number
Current length.

Remarks
Time O(1), Space O(1)
Overrides LinearBase.length
- Defined in data-structures/queue/deque.ts:274

maxLen

get maxLen(): number
Upper bound for length (if positive), or -1 when unbounded.

Returns number
Maximum allowed length.

Remarks
Time O(1), Space O(1)
Inherited from LinearBase.maxLen
- Defined in data-structures/base/linear-base.ts:100

toElementFn

get toElementFn(): undefined | ((rawElement: R) => E)
Exposes the current toElementFn, if configured.

Returns undefined | ((rawElement: R) => E)
The converter function or undefined when not set.

Remarks
Time O(1), Space O(1).
Inherited from LinearBase.toElementFn
- Defined in data-structures/base/iterable-element-base.ts:47

Methods

`Protected`_createInstance

_createInstance(options?): this
(Protected) Create an empty instance of the same concrete class.
Parameters
- Optionaloptions: LinearBaseOptions<E, R>
  Options forwarded to the constructor.
Returns this
An empty like-kind deque instance.

Remarks
Time O(1), Space O(1)
Overrides LinearBase._createInstance
- Defined in data-structures/queue/deque.ts:960

`Protected`_createLike

_createLike<T, RR>(elements?, options?): any
(Protected) Create a like-kind deque seeded by elements.
Type Parameters
- T = E
- RR = R
Parameters
- Optionalelements: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR> = []
  Iterable used to seed the new deque.
- Optionaloptions: DequeOptions<T, RR>
  Options forwarded to the constructor.
Returns any
A like-kind Deque instance.

Remarks
Time O(N), Space O(N)
- Defined in data-structures/queue/deque.ts:978

`Protected`_getBucketAndPosition

_getBucketAndPosition(pos): {
bucketIndex: number;
indexInBucket: number;
}
(Protected) Translate a logical position to bucket/offset.
Parameters
- pos: number
  Zero-based position.
Returns {
bucketIndex: number;
indexInBucket: number;
}
An object containing bucketIndex and indexInBucket.
- bucketIndex: number
- indexInBucket: number
Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:934

`Protected`_getIterator

_getIterator(): IterableIterator<E, any, any>
(Protected) Iterate elements from front to back.

Returns IterableIterator<E, any, any>
Iterator of elements.

Remarks
Time O(N), Space O(1)
Overrides LinearBase._getIterator
- Defined in data-structures/queue/deque.ts:891

`Protected`_getReverseIterator

_getReverseIterator(): IterableIterator<E, any, any>
(Protected) Iterate elements from back to front.

Returns IterableIterator<E, any, any>
Iterator of elements.

Remarks
Time O(N), Space O(1)
Overrides LinearBase._getReverseIterator
- Defined in data-structures/queue/deque.ts:995

`Protected`_reallocate

_reallocate(needBucketNum?): void
(Protected) Reallocate buckets to make room near the ends.
Parameters
- OptionalneedBucketNum: number
  How many extra buckets to add; defaults to half of current.
Returns void
void

Remarks
Time O(N), Space O(N)
- Defined in data-structures/queue/deque.ts:905

`Protected`_setBucketSize

_setBucketSize(size): void
(Protected) Set the internal bucket size.
Parameters
- size: number
  Bucket capacity to assign.
Returns void
void

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:881

[iterator]

[iterator](...args): IterableIterator<E, any, any>
Returns an iterator over the structure's elements.
Parameters
- Rest...args: unknown[]
  Optional iterator arguments forwarded to the internal iterator.
Returns IterableIterator<E, any, any>
An IterableIterator<E> that yields the elements in traversal order.

Remarks
Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
Inherited from LinearBase.[iterator]
- Defined in data-structures/base/iterable-element-base.ts:60

addAt

addAt(pos, element, num?): boolean
Insert repeated copies of an element at a position.
Parameters
- pos: number
  Zero-based position from the front.
- element: E
  Element to insert.
- Optionalnum: number = 1
  Number of times to insert (default 1).
Returns boolean
True if inserted.

Remarks
Time O(N), Space O(1)
Overrides LinearBase.addAt
- Defined in data-structures/queue/deque.ts:520

at

at(pos): undefined | E
Get the element at a given position.
Parameters
- pos: number
  Zero-based position from the front.
Returns undefined | E
Element or undefined.

Remarks
Time O(1), Space O(1)
Overrides LinearBase.at
- Defined in data-structures/queue/deque.ts:490

clear

clear(): void
Remove all elements and reset structure.

Returns void
void

Remarks
Time O(1), Space O(1)
Overrides LinearBase.clear
- Defined in data-structures/queue/deque.ts:476

clone

clone(): this
Deep clone this deque, preserving options.

Returns this
A new deque with the same content and options.

Remarks
Time O(N), Space O(N)
Overrides LinearBase.clone
- Defined in data-structures/queue/deque.ts:798

concat

concat(...items): this
Concatenate multiple containers of the same species.
Parameters
- Rest...items: Deque<E, R>[]
  Other lists to append.
Returns this
New container with combined elements (this type).

Remarks
Time O(sum(length)), Space O(sum(length))
Inherited from LinearBase.concat
- Defined in data-structures/base/linear-base.ts:165

cut

cut(pos, isCutSelf?): Deque<E, any>
Cut the deque to keep items up to index; optionally mutate in-place.
Parameters
- pos: number
  Last index to keep.
- OptionalisCutSelf: boolean = false
  When true, mutate this deque; otherwise return a new deque.
Returns Deque<E, any>
This deque if in-place; otherwise a new deque of the prefix.

Remarks
Time O(N), Space O(1)
- Defined in data-structures/queue/deque.ts:548

cutRest

cutRest(pos, isCutSelf?): Deque<E, any>
Cut the deque to keep items from index onward; optionally mutate in-place.
Parameters
- pos: number
  First index to keep.
- OptionalisCutSelf: boolean = false
  When true, mutate this deque; otherwise return a new deque.
Returns Deque<E, any>
This deque if in-place; otherwise a new deque of the suffix.

Remarks
Time O(N), Space O(1)
- Defined in data-structures/queue/deque.ts:615

delete

delete(element): boolean
Delete the first occurrence of a value.
Parameters
- element: E
  Element to remove (using the configured equality).
Returns boolean
True if an element was removed.

Remarks
Time O(N), Space O(1)
Overrides LinearBase.delete
- Defined in data-structures/queue/deque.ts:677

deleteAt

deleteAt(pos): undefined | E
Delete the element at a given position.
Parameters
- pos: number
  Zero-based position from the front.
Returns undefined | E
Removed element or undefined.

Remarks
Time O(N), Space O(1)
Overrides LinearBase.deleteAt
- Defined in data-structures/queue/deque.ts:644

deleteWhere

deleteWhere(predicate): boolean
Delete the first element matching a predicate.
Parameters
- predicate: ((value: E, index: number, deque: this) => boolean)
  Function (value, index, deque) → boolean.
  - - (value, index, deque): boolean
    - Parameters
      value: E
      index: number
      deque: this
      Returns boolean
Returns boolean
True if a match was removed.

Remarks
Time O(N), Space O(1)
- Defined in data-structures/queue/deque.ts:701

every

every(predicate, thisArg?): boolean
Tests whether all elements satisfy the predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  Function invoked for each element with signature (value, index, self).
- OptionalthisArg: unknown
  Optional this binding for the predicate.
Returns boolean
true if every element passes; otherwise false.

Remarks
Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
Inherited from LinearBase.every
- Defined in data-structures/base/iterable-element-base.ts:86

fill

fill(value, start?, end?): this
Fill a range with a value.
Parameters
- value: E
  Value to set.
- start: number = 0
  Inclusive start.
- end: number = ...
  Exclusive end.
Returns this
This list.

Remarks
Time O(n), Space O(1)
Inherited from LinearBase.fill
- Defined in data-structures/base/linear-base.ts:300

filter

filter(predicate, thisArg?): this
Filter elements into a new deque of the same class.
Parameters
- predicate: ElementCallback<E, R, boolean>
  Predicate (value, index, deque) → boolean to keep element.
- OptionalthisArg: any
  Value for this inside the predicate.
Returns this
A new deque with kept elements.

Remarks
Time O(N), Space O(N)
Overrides LinearBase.filter
- Defined in data-structures/queue/deque.ts:814

find

find<S>(predicate, thisArg?): undefined | S
Finds the first element that satisfies the predicate and returns it.

Finds the first element of type S (a subtype of E) that satisfies the predicate and returns it.
Type Parameters
- S
Parameters
- predicate: ElementCallback<E, R, S>
  Type-guard predicate: (value, index, self) => value is S.
- OptionalthisArg: unknown
  Optional this binding for the predicate.
Returns undefined | S
The matched element typed as S, or undefined if not found.

Remarks
Time O(n) in the worst case; may exit early on the first match. Space O(1).
Inherited from LinearBase.find
- Defined in data-structures/base/iterable-element-base.ts:162

findIndex

findIndex(predicate, thisArg?): number
Find the first index matching a predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  (element, index, self) => boolean.
- OptionalthisArg: any
  Optional this for callback.
Returns number
Index or -1.

Remarks
Time O(n), Space O(1)
Inherited from LinearBase.findIndex
- Defined in data-structures/base/linear-base.ts:151

forEach

forEach(callbackfn, thisArg?): void
Invokes a callback for each element in iteration order.
Parameters
- callbackfn: ElementCallback<E, R, void>
  Function invoked per element with signature (value, index, self).
- OptionalthisArg: unknown
  Optional this binding for the callback.
Returns void
void.

Remarks
Time O(n), Space O(1).
Inherited from LinearBase.forEach
- Defined in data-structures/base/iterable-element-base.ts:132

has

has(element): boolean
Checks whether a strictly-equal element exists in the structure.
Parameters
- element: E
  The element to test with === equality.
Returns boolean
true if an equal element is found; otherwise false.

Remarks
Time O(n) in the worst case. Space O(1).
Inherited from LinearBase.has
- Defined in data-structures/base/iterable-element-base.ts:188

indexOf

indexOf(searchElement, fromIndex?): number
First index of a value from the left.
Parameters
- searchElement: E
  Value to match.
- fromIndex: number = 0
  Start position (supports negative index).
Returns number
Index or -1 if not found.

Remarks
Time O(n), Space O(1)
Inherited from LinearBase.indexOf
- Defined in data-structures/base/linear-base.ts:111

isEmpty

isEmpty(): boolean
Check whether the deque is empty.

Returns boolean
True if length is 0.

Remarks
Time O(1), Space O(1)
Overrides LinearBase.isEmpty
- Defined in data-structures/queue/deque.ts:466

join

join(separator?): string
Join all elements into a string.
Parameters
- separator: string = ','
  Separator string.
Returns string
Concatenated string.

Remarks
Time O(n), Space O(n)
Inherited from LinearBase.join
- Defined in data-structures/base/linear-base.ts:236

lastIndexOf

lastIndexOf(searchElement, fromIndex?): number
Last index of a value from the right.
Parameters
- searchElement: E
  Value to match.
- fromIndex: number = ...
  Start position (supports negative index).
Returns number
Index or -1 if not found.

Remarks
Time O(n), Space O(1)
Inherited from LinearBase.lastIndexOf
- Defined in data-structures/base/linear-base.ts:131

map

map<EM, RM>(callback, options?, thisArg?): Deque<EM, RM>
Map elements into a new deque (possibly different element type).
Type Parameters
- EM
- RM
Parameters
- callback: ElementCallback<E, R, EM>
  Mapping function (value, index, deque) → newElement.
- Optionaloptions: IterableElementBaseOptions<EM, RM>
  Options for the output deque (e.g., bucketSize, toElementFn, maxLen).
- OptionalthisArg: any
  Value for this inside the callback.
Returns Deque<EM, RM>
A new Deque with mapped elements.

Remarks
Time O(N), Space O(N)
Overrides LinearBase.map
- Defined in data-structures/queue/deque.ts:855

mapSame

mapSame(callback, thisArg?): this
Map elements into a new deque of the same element type.
Parameters
- callback: ElementCallback<E, R, E>
  Mapping function (value, index, deque) → newValue.
- OptionalthisArg: any
  Value for this inside the callback.
Returns this
A new deque with mapped values.

Remarks
Time O(N), Space O(N)
Overrides LinearBase.mapSame
- Defined in data-structures/queue/deque.ts:833

pop

pop(): undefined | E
Remove and return the last element.

Returns undefined | E
Removed element or undefined.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:354

print

print(): void
Prints toVisual() to the console. Intended for quick debugging.

Returns void
void.

Remarks
Time O(n) due to materialization, Space O(n) for the intermediate representation.
Inherited from LinearBase.print
- Defined in data-structures/base/iterable-element-base.ts:268

push

push(element): boolean
Append one element at the back.
Parameters
- element: E
  Element to append.
Returns boolean
True when appended.

Remarks
Time O(1) amortized, Space O(1)
Overrides LinearBase.push
- Defined in data-structures/queue/deque.ts:329

pushMany

pushMany(elements): boolean[]
Append a sequence of elements.
Parameters
- elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>
  Iterable (or iterable-like) of elements/records.
Returns boolean[]
Array of per-element success flags.

Remarks
Time O(N), Space O(1)
Overrides LinearBase.pushMany
- Defined in data-structures/queue/deque.ts:429

reduce

reduce(callbackfn): E
Parameters
- callbackfn: ReduceElementCallback<E, R>
Returns E
Inherited from LinearBase.reduce
- Defined in data-structures/base/iterable-element-base.ts:193
reduce(callbackfn, initialValue): E
Parameters
- callbackfn: ReduceElementCallback<E, R>
- initialValue: E
Returns E
Inherited from LinearBase.reduce
- Defined in data-structures/base/iterable-element-base.ts:194
reduce<U>(callbackfn, initialValue): U
Type Parameters
- U
Parameters
- callbackfn: ReduceElementCallback<E, R, U>
- initialValue: U
Returns U
Inherited from LinearBase.reduce
- Defined in data-structures/base/iterable-element-base.ts:195

reduceRight

reduceRight<U>(callbackfn, initialValue): U
Right-to-left reduction over elements.
Type Parameters
- U
Parameters
- callbackfn: ReduceLinearCallback<E, U>
  (acc, element, index, self) => acc.
- initialValue: U
  Initial accumulator (optional generic overloads supported).
Returns U
Final accumulator.

Remarks
Time O(n), Space O(1)
Inherited from LinearBase.reduceRight
- Defined in data-structures/base/linear-base.ts:264

reverse

reverse(): this
Reverse the deque by reversing buckets and pointers.

Returns this
This deque.

Remarks
Time O(N), Space O(N)
Overrides LinearBase.reverse
- Defined in data-structures/queue/deque.ts:730

setAt

setAt(pos, element): boolean
Replace the element at a given position.
Parameters
- pos: number
  Zero-based position from the front.
- element: E
  New element value.
Returns boolean
True if updated.

Remarks
Time O(1), Space O(1)
Overrides LinearBase.setAt
- Defined in data-structures/queue/deque.ts:504

setEquality

setEquality(equals): this
Set the equality comparator used by delete operations.
Parameters
- equals: ((a: E, b: E) => boolean)
  Equality predicate (a, b) → boolean.
  - - (a, b): boolean
    - Parameters
      a: E
      b: E
      Returns boolean
Returns this
This deque.

Remarks
Time O(1), Space O(1)
- Defined in data-structures/queue/deque.ts:719

shift

shift(): undefined | E
Remove and return the first element.

Returns undefined | E
Removed element or undefined.

Remarks
Time O(1) amortized, Space O(1)
- Defined in data-structures/queue/deque.ts:378

shrinkToFit

shrinkToFit(): void
Trim unused buckets to fit exactly the active range.

Returns void
void

Remarks
Time O(N), Space O(1)
- Defined in data-structures/queue/deque.ts:771

slice

slice(start?, end?): this
Create a shallow copy of a subrange.
Parameters
- start: number = 0
  Inclusive start (supports negative index).
- end: number = ...
  Exclusive end (supports negative index).
Returns this
New list with the range (this type).

Remarks
Time O(n), Space O(n)
Inherited from LinearBase.slice
- Defined in data-structures/base/linear-base.ts:281

some

some(predicate, thisArg?): boolean
Tests whether at least one element satisfies the predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  Function invoked for each element with signature (value, index, self).
- OptionalthisArg: unknown
  Optional this binding for the predicate.
Returns boolean
true if any element passes; otherwise false.

Remarks
Time O(n) in the worst case; may exit early on first success. Space O(1).
Inherited from LinearBase.some
- Defined in data-structures/base/iterable-element-base.ts:109

sort

sort(compareFn?): this
In-place stable order via array sort semantics.
Parameters
- OptionalcompareFn: ((a: E, b: E) => number)
  Comparator (a, b) => number.
  - - (a, b): number
    - Parameters
      a: E
      b: E
      Returns number
Returns this
This container.

Remarks
Time O(n log n), Space O(n) (materializes to array temporarily)
Inherited from LinearBase.sort
- Defined in data-structures/base/linear-base.ts:193

splice

splice(start, deleteCount?, ...items?): this
Remove and/or insert elements at a position (array-like behavior).
Parameters
- start: number
  Start index (clamped to [0, length]).
- OptionaldeleteCount: number = ...
  Number of elements to remove (default: length - start).
- Optional Rest...items: E[]
  Elements to insert after start.
Returns this
A new deque containing the removed elements (typed as this).

Remarks
Time O(N + M), Space O(M)
Overrides LinearBase.splice
- Defined in data-structures/queue/deque.ts:580

toArray

toArray(): E[]
Materializes the elements into a new array.

Returns E[]
A shallow array copy of the iteration order.

Remarks
Time O(n), Space O(n).
Inherited from LinearBase.toArray
- Defined in data-structures/base/iterable-element-base.ts:245

toReversedArray

toReversedArray(): E[]
Snapshot elements into a reversed array.

Returns E[]
New reversed array.

Remarks
Time O(n), Space O(n)
Inherited from LinearBase.toReversedArray
- Defined in data-structures/base/linear-base.ts:245

toVisual

toVisual(): E[]
Returns a representation of the structure suitable for quick visualization. Defaults to an array of elements; subclasses may override to provide richer visuals.

Returns E[]
A visual representation (array by default).

Remarks
Time O(n), Space O(n).
Inherited from LinearBase.toVisual
- Defined in data-structures/base/iterable-element-base.ts:257

unique

unique(): this
Deduplicate consecutive equal elements in-place.

Returns this
This deque.

Remarks
Time O(N), Space O(1)
- Defined in data-structures/queue/deque.ts:748

unshift

unshift(element): boolean
Prepend one element at the front.
Parameters
- element: E
  Element to prepend.
Returns boolean
True when prepended.

Remarks
Time O(1) amortized, Space O(1)
- Defined in data-structures/queue/deque.ts:403

unshiftMany

unshiftMany(elements?): boolean[]
Prepend a sequence of elements.
Parameters
- Optionalelements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = []
  Iterable (or iterable-like) of elements/records.
Returns boolean[]
Array of per-element success flags.

Remarks
Time O(N), Space O(1)
- Defined in data-structures/queue/deque.ts:448

values

values(): IterableIterator<E, any, any>
Returns an iterator over the values (alias of the default iterator).

Returns IterableIterator<E, any, any>
An IterableIterator<E> over all elements.

Remarks
Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
Inherited from LinearBase.values
- Defined in data-structures/base/iterable-element-base.ts:71

`Static`fromArray

fromArray<E, R>(this, data, options?): any
Create a Deque from an array of elements.
Type Parameters
- E
- R = any
Parameters
- this: Object
  Constructor (subclass) to instantiate.
- data: E[]
  Array of elements to insert in order.
- Optionaloptions: DequeOptions<E, R>
  Options forwarded to the constructor.
Returns any
A new Deque populated from the array.

Remarks
Time O(N), Space O(N)
- Defined in data-structures/queue/deque.ts:311

Class Deque<E, R>

Remarks

Example

Example

Example

Example

Example

Type Parameters

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns Deque<E, R>

Remarks

Properties

Protected Optional_toElementFn

Remarks

Accessors

bucketCount

Returns number

Remarks

bucketFirst

Returns number

Remarks

bucketLast

Returns number

Remarks

buckets

Returns E[][]

Remarks

bucketSize

Returns number

Remarks

first

Returns undefined | E

Remarks

firstInBucket

Returns number

Remarks

last

Returns undefined | E

Remarks

lastInBucket

Returns number

Remarks

length

Returns number

Remarks

maxLen

Returns number

Remarks

toElementFn

Returns undefined | ((rawElement: R) => E)

Remarks

Methods

Protected_createInstance

Parameters

Returns this

Remarks

Protected_createLike

Type Parameters

Parameters

Returns any

Remarks

Protected_getBucketAndPosition

Parameters

Returns { bucketIndex: number; indexInBucket: number; }

bucketIndex: number

indexInBucket: number

Remarks

Protected_getIterator

Returns IterableIterator<E, any, any>

Remarks

Protected_getReverseIterator

`Protected` `Optional`_toElementFn

`Protected`_createInstance

`Protected`_createLike

`Protected`_getBucketAndPosition

Returns {
bucketIndex: number;
indexInBucket: number;
}

`Protected`_getIterator

`Protected`_getReverseIterator

`Protected`_reallocate

`Protected`_setBucketSize