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

// prize roulette
    class PrizeRoulette {
      private deque: Deque<string>;

      constructor(prizes: string[]) {
        // Initialize the deque with prizes
        this.deque = new Deque<string>(prizes);
      }

      // Rotate clockwise to the right (forward)
      rotateClockwise(steps: number): void {
        const n = this.deque.length;
        if (n === 0) return;

        for (let i = 0; i < steps; i++) {
          const last = this.deque.pop(); // Remove the last element
          this.deque.unshift(last!); // Add it to the front
        }
      }

      // Rotate counterclockwise to the left (backward)
      rotateCounterClockwise(steps: number): void {
        const n = this.deque.length;
        if (n === 0) return;

        for (let i = 0; i < steps; i++) {
          const first = this.deque.shift(); // Remove the first element
          this.deque.push(first!); // Add it to the back
        }
      }

      // Display the current prize at the head
      display() {
        return this.deque.first;
      }
    }

    // Example usage
    const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list
    const roulette = new PrizeRoulette(prizes);

    // Display the initial state
    console.log(roulette.display()); // 'Car' // Car

    // Rotate clockwise by 3 steps
    roulette.rotateClockwise(3);
    console.log(roulette.display()); // 'Phone' // Phone

    // Rotate counterclockwise by 2 steps
    roulette.rotateCounterClockwise(2);
    console.log(roulette.display()); // 'Headphones'

Example

// sliding window
    // Maximum function of sliding window
    function maxSlidingWindow(nums: number[], k: number): number[] {
      const n = nums.length;
      if (n * k === 0) return [];

      const deq = new Deque<number>();
      const result: number[] = [];

      for (let i = 0; i < n; i++) {
        // Delete indexes in the queue that are not within the window range
        if (deq.length > 0 && deq.first! === i - k) {
          deq.shift();
        }

        // Remove all indices less than the current value from the tail of the queue
        while (deq.length > 0 && nums[deq.last!] < nums[i]) {
          deq.pop();
        }

        // Add the current index to the end of the queue
        deq.push(i);

        // Add the maximum value of the window to the results
        if (i >= k - 1) {
          result.push(nums[deq.first!]);
        }
      }

      return result;
    }

    const nums = [1, 3, -1, -3, 5, 3, 6, 7];
    const k = 3;
    console.log(maxSlidingWindow(nums, k)); // [3, 3, 5, 5, 6, 7]

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:129

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:222

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:174

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:198

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:234

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:162

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:256

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:186

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:267

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:210

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:246

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:932

`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:950

`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:906

`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:863

`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:967

`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:877

`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:853

[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:492

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:462

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:448

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:770

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:520

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:587

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:649

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:616

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:673

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:786

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:438

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:827

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:805

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:326

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:301

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:401

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:702

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:476

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:691

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:350

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:743

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:552

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:720

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:375

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:420

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:283

Class Deque<E, R>

Remarks

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

Returns IterableIterator<E, any, any>

Remarks

Protected_reallocate

`Protected` `Optional`_toElementFn

`Protected`_createInstance

`Protected`_createLike

`Protected`_getBucketAndPosition

Returns {
bucketIndex: number;
indexInBucket: number;
}

`Protected`_getIterator

`Protected`_getReverseIterator

`Protected`_reallocate

`Protected`_setBucketSize