Class Deque<E, R>

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).
Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.
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.
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).
Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not

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

Hierarchy

LinearBase<E, R>
- Deque

Constructors

constructor

new Deque<E, R>(elements?, options?): Deque<E, R>
The constructor initializes a Deque object with optional iterable of elements and options.
Type Parameters
- E = any
- R = any
Parameters
- elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = []
  An iterable object (such as an array or a Set) that contains the initial elements to be added to the deque. It can also be an object with a length or size property that represents the number of elements in the iterable object. If no elements are provided, an empty deque
- Optionaloptions: DequeOptions<E, R>
  The options parameter is an optional object that can contain configuration options for the deque. In this code, it is used to set the bucketSize option, which determines the size of each bucket in the deque. If the bucketSize option is not provided or is not a number
Returns Deque<E, R>
Overrides LinearBase<E, R>.constructor
- Defined in queue/deque.ts:119

Accessors

first

get first(): undefined | E
The function returns the first element in a collection if it exists, otherwise it returns undefined.

Returns undefined | E
The first element of the collection, of type E, is being returned.
- Defined in queue/deque.ts:199

last

get last(): undefined | E
The last function returns the last element in the queue.

Returns undefined | E
The last element in the array
- Defined in queue/deque.ts:208

Methods

`Protected`_createInstance

_createInstance(options?): this
The function _createInstance returns a new instance of the Deque class with the specified options.
Parameters
- Optionaloptions: DequeOptions<E, R>
  The options parameter in the _createInstance method is of type DequeOptions<E, R>, which is an optional parameter that allows you to pass additional configuration options when creating a new instance of the Deque class.
Returns this
An instance of the Deque class with an empty array and the provided options, casted as this.
Overrides LinearBase._createInstance
- Defined in queue/deque.ts:937

`Protected`_getBucketAndPosition

_getBucketAndPosition(pos): {
bucketIndex: number;
indexInBucket: number;
}
Time Complexity: O(1) Space Complexity: O(1)

The function calculates the bucket index and index within the bucket based on the given position.
Parameters
- pos: number
  The pos parameter represents the position within the data structure. It is a number that indicates the index or position of an element within the structure.
Returns {
bucketIndex: number;
indexInBucket: number;
}
an object with two properties: "bucketIndex" and "indexInBucket".
- bucketIndex: number
- indexInBucket: number
- Defined in queue/deque.ts:909

`Protected`_getIterator

_getIterator(): IterableIterator<E, any, any>
Time Complexity: O(n) Space Complexity: O(1)

The above function is an implementation of the iterator protocol in TypeScript, allowing the object to be iterated over using a for...of loop.

Returns IterableIterator<E, any, any>
Overrides LinearBase._getIterator
- Defined in queue/deque.ts:863

`Protected`_getReverseIterator

_getReverseIterator(): IterableIterator<E, any, any>
This function returns an iterator that iterates over elements in reverse order.

Returns IterableIterator<E, any, any>
Overrides LinearBase._getReverseIterator
- Defined in queue/deque.ts:944

`Protected`_reallocate

_reallocate(needBucketNum?): void
Time Complexity: O(n) Space Complexity: O(n)

The _reallocate function reallocates the buckets in an array, adding new buckets if needed.
Parameters
- OptionalneedBucketNum: number
  The needBucketNum parameter is an optional number that specifies the number of new buckets needed. If not provided, it will default to half of the current bucket count (this._bucketCount >> 1) or 1 if the current bucket count is less than 2.
Returns void
- Defined in queue/deque.ts:878

[iterator]

[iterator](...args): IterableIterator<E, any, any>
Time Complexity: O(n) Space Complexity: O(1)

The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
Parameters
- Rest...args: any[]
  The args parameter in the code snippet represents a rest parameter. It allows the function to accept any number of arguments as an array. In this case, the args parameter is used to pass any number of arguments to the _getIterator method.
Returns IterableIterator<E, any, any>
Inherited from LinearBase.[iterator]
- Defined in base/iterable-element-base.ts:32

addAt

addAt(pos, element, num?): boolean
Time Complexity: O(n) Space Complexity: O(n)

The addAt function inserts one or more elements at a specified position in an array-like data structure.
Parameters
- pos: number
  The pos parameter represents the position at which the element(s) should be inserted. It is of type number.
- element: E
  The element parameter represents the element that you want to insert into the array at the specified position.
- Optionalnum: number = 1
  The num parameter represents the number of times the element should be inserted at the specified position (pos). By default, it is set to 1, meaning that the element will be inserted once. However, you can provide a different value for num if you want
Returns boolean
The size of the array after the insertion is being returned.
Overrides LinearBase.addAt
- Defined in queue/deque.ts:447

at

at(pos): E
Time Complexity: O(1) Space Complexity: O(1)

The at function retrieves an element at a specified position in an array-like data structure.
Parameters
- pos: number
  The pos parameter represents the position of the element that you want to retrieve from the data structure. It is of type number and should be a valid index within the range of the data structure.
Returns E
The element at the specified position in the data structure is being returned.
Overrides LinearBase.at
- Defined in queue/deque.ts:409

clear

clear(): void
Time Complexity: O(1) Space Complexity: O(1)

The clear() function resets the state of the object by initializing all variables to their default values.

Returns void
Overrides LinearBase.clear
- Defined in queue/deque.ts:392

clone

clone(): this
Time Complexity: O(n) Space Complexity: O(n)

The clone() function returns a new instance of the Deque class with the same elements and bucket size as the original instance.

Returns this
The clone() method is returning a new instance of the Deque class with the same elements as the original deque (this) and the same bucket size.
Overrides LinearBase.clone
- Defined in queue/deque.ts:788

concat

concat(...items): this
Parameters
- Rest...items: Deque<E, R>[]
  The concat method takes in an array of items, where each item can be either of type E or an instance of LinearBase<E, R>.
Returns this
The concat method is returning a new instance of the class that it belongs to, with the items passed as arguments concatenated to it.
Inherited from LinearBase.concat
- Defined in base/linear-base.ts:144

cut

cut(pos, isCutSelf?): Deque<E, any>
Time Complexity: O(1) Space Complexity: O(1)

The cut function updates the state of the object based on the given position and returns the updated size.
Parameters
- pos: number
  The pos parameter represents the position at which the string should be cut. It is a number that indicates the index of the character where the cut should be made.
- isCutSelf: boolean = false
  If true, the original deque will not be cut, and return a new deque
Returns Deque<E, any>
The method is returning the updated size of the data structure.
- Defined in queue/deque.ts:477

cutRest

cutRest(pos, isCutSelf?): Deque<E, any>
Time Complexity: O(1) Space Complexity: O(1) or O(n)

The cutRest function cuts the elements from a specified position in a deque and returns a new deque with the cut elements.
Parameters
- pos: number
  The pos parameter represents the position from which to cut the Deque. It is a number that indicates the index of the element in the Deque where the cut should start.
- OptionalisCutSelf: boolean = false
  isCutSelf is a boolean parameter that determines whether the original Deque should be modified or a new Deque should be created. If isCutSelf is true, the original Deque will be modified by cutting off elements starting from the specified position. If isCutSelf is false, a new De
Returns Deque<E, any>
The function cutRest returns either the modified original deque (this) or a new deque (newDeque) depending on the value of the isCutSelf parameter.
- Defined in queue/deque.ts:573

delete

delete(element): boolean
Time Complexity: O(n) Space Complexity: O(1)

The delete function removes all occurrences of a specified element from an array-like data structure.
Parameters
- element: E
  The element parameter represents the element that you want to delete from the data structure.
Returns boolean
The size of the data structure after the element has been deleted.
Overrides LinearBase.delete
- Defined in queue/deque.ts:649

deleteAt

deleteAt(pos): undefined | E
Time Complexity: O(n) Space Complexity: O(1) or O(n)

The deleteAt function removes an element at a specified position in an array-like data structure.
Parameters
- pos: number
  The pos parameter in the deleteAt function represents the position at which an element needs to be deleted from the data structure. It is of type number and indicates the index of the element to be deleted.
Returns undefined | E
The size of the data structure after the deletion operation is performed.
Overrides LinearBase.deleteAt
- Defined in queue/deque.ts:609

every

every(predicate, thisArg?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The every function checks if every element in the array satisfies a given predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter is a callback function that takes three arguments: the current element being processed, its index, and the array it belongs to. It should return a boolean value indicating whether the element satisfies a certain condition or not.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the predicate function. If thisArg is provided, it will be passed as the this value to the predicate function. If thisArg is
Returns boolean
The every method is returning a boolean value. It returns true if every element in the array satisfies the provided predicate function, and false otherwise.
Inherited from LinearBase.every
- Defined in base/iterable-element-base.ts:62

fill

fill(value, start?, end?): this
Time Complexity: O(n) Space Complexity: O(1)

The fill function in TypeScript fills a specified range in an array-like object with a given value.
Parameters
- value: E
  The value parameter in the fill method represents the element that will be used to fill the specified range in the array.
- Optionalstart: number = 0
  The start parameter specifies the index at which to start filling the array with the specified value. If not provided, it defaults to 0, indicating the beginning of the array.
- end: number = ...
  The end parameter in the fill function represents the index at which the filling of values should stop. It specifies the end of the range within the array where the value should be filled.
Returns this
The fill method is returning the modified object (this) after filling the specified range with the provided value.
Inherited from LinearBase.fill
- Defined in base/linear-base.ts:343

filter

filter(predicate, thisArg?): Deque<E, R>
Time Complexity: O(n) Space Complexity: O(n)

The filter function creates a new deque containing elements from the original deque that satisfy a given predicate function.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter is a callback function that takes three arguments: the current element being iterated over, the index of the current element, and the deque itself. It should return a boolean value indicating whether the element should be included in the filtered deque or not.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the predicate function. If thisArg is provided, it will be passed as the this value to the predicate function. If thisArg is
Returns Deque<E, R>
The filter method is returning a new Deque object that contains the elements that satisfy the given predicate function.
Overrides LinearBase.filter
- Defined in queue/deque.ts:812

find

find<S>(predicate, thisArg?): undefined | S
Type Parameters
- S
Parameters
- predicate: ElementCallback<E, R, S>
- OptionalthisArg: any
Returns undefined | S
Inherited from LinearBase.find
- Defined in base/iterable-element-base.ts:116
find(predicate, thisArg?): undefined | E
Parameters
- predicate: ElementCallback<E, R, unknown>
- OptionalthisArg: any
Returns undefined | E
Inherited from LinearBase.find
- Defined in base/iterable-element-base.ts:117

findIndex

findIndex(predicate, thisArg?): number
Time Complexity: O(n) Space Complexity: O(1)

The findIndex function iterates over an array and returns the index of the first element that satisfies the provided predicate function.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter in the findIndex function is a callback function that takes three arguments: item, index, and the array this. It should return a boolean value indicating whether the current element satisfies the condition being checked for.
- OptionalthisArg: any
  The thisArg parameter in the findIndex function is an optional parameter that specifies the value to use as this when executing the predicate function. If provided, the predicate function will be called with thisArg as its this value. If @returns ThefindIndex` method is returning the index of the first element in the array that satisfies the provided predicate function. If no such element is found, it returns -1.
Returns number
Inherited from LinearBase.findIndex
- Defined in base/linear-base.ts:136

forEach

forEach(callbackfn, thisArg?): void
Time Complexity: O(n) Space Complexity: O(1)

The forEach function iterates over each element in an array-like object and calls a callback function for each element.
Parameters
- callbackfn: ElementCallback<E, R, void>
  The callbackfn parameter is a function that will be called for each element in the array. It takes three arguments: the current element being processed, the index of the current element, and the array that forEach was called upon.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the callbackfn function. If thisArg is provided, it will be passed as the this value to the callbackfn function. If `thisArg
Returns void
Inherited from LinearBase.forEach
- Defined in base/iterable-element-base.ts:109

has

has(element): boolean
Time Complexity: O(n) Space Complexity: O(1)

The function checks if a given element exists in a collection.
Parameters
- element: E
  The parameter "element" is of type E, which means it can be any type. It represents the element that we want to check for existence in the collection.
Returns boolean
a boolean value. It returns true if the element is found in the collection, and false otherwise.
Inherited from LinearBase.has
- Defined in base/iterable-element-base.ts:154

indexOf

indexOf(searchElement, fromIndex?): number
Time Complexity: O(n) Space Complexity: O(1)

The function indexOf searches for a specified element starting from a given index in an array-like object and returns the index of the first occurrence, or -1 if not found.
Parameters
- searchElement: E
  The searchElement parameter in the indexOf function represents the element that you want to find within the array. The function will search for this element starting from the fromIndex (if provided) up to the end of the array. If the searchElement is found within the
- OptionalfromIndex: number = 0
  The fromIndex parameter in the indexOf function represents the index at which to start searching for the searchElement within the array. If provided, the search will begin at this index and continue to the end of the array. If fromIndex is not specified, the default
Returns number
The indexOf method is returning the index of the searchElement if it is found in the array starting from the fromIndex. If the searchElement is not found, it returns -1.
Inherited from LinearBase.indexOf
- Defined in base/linear-base.ts:76

isEmpty

isEmpty(): boolean
Time Complexity: O(1) Space Complexity: O(1)

The function checks if the size of an object is equal to zero and returns a boolean value.

Returns boolean
A boolean value indicating whether the size of the object is 0 or not.
Overrides LinearBase.isEmpty
- Defined in queue/deque.ts:381

join

join(separator?): string
Time Complexity: O(n) Space Complexity: O(1)

The join function in TypeScript returns a string by joining the elements of an array with a specified separator.
Parameters
- Optionalseparator: string = ','
  The separator parameter is a string that specifies the character or characters that will be used to separate each element when joining them into a single string. By default, the separator is set to a comma (,), but you can provide a different separator if needed.
Returns string
The join method is being returned, which takes an optional separator parameter (defaulting to a comma) and returns a string created by joining all elements of the array after converting it to an array.
Inherited from LinearBase.join
- Defined in base/linear-base.ts:249

lastIndexOf

lastIndexOf(searchElement, fromIndex?): number
Time Complexity: O(n) Space Complexity: O(1)

The function lastIndexOf in TypeScript returns the index of the last occurrence of a specified element in an array.
Parameters
- searchElement: E
  The searchElement parameter is the element that you want to find the last index of within the array. The lastIndexOf method will search the array starting from the fromIndex (or the end of the array if not specified) and return the index of the last occurrence of the
- fromIndex: number = ...
  The fromIndex parameter in the lastIndexOf method specifies the index at which to start searching for the searchElement in the array. By default, it starts searching from the last element of the array (this.length - 1). If a specific fromIndex is provided
Returns number
The last index of the searchElement in the array is being returned. If the searchElement is not found in the array, -1 is returned.
Inherited from LinearBase.lastIndexOf
- Defined in base/linear-base.ts:108

map

map<EM, RM>(callback, toElementFn?, thisArg?): Deque<EM, RM>
Time Complexity: O(n) Space Complexity: O(n)

The map function takes a callback function and applies it to each element in the deque, returning a new deque with the results.
Type Parameters
- EM
- RM
Parameters
- callback: ElementCallback<E, R, EM>
  The callback parameter is a function that will be called for each element in the deque. It takes three arguments: the current element, the index of the element, and the deque itself. It should return a value of type EM.
- OptionaltoElementFn: ((rawElement: RM) => EM)
  The toElementFn parameter is an optional function that can be used to transform the raw element (RM) into a new element (EM) before adding it to the new deque. If provided, this function will be called for each raw element in the original deque.
  - - (rawElement): EM
    - Parameters
      rawElement: RM
      Returns EM
- OptionalthisArg: any
  The thisArg parameter is an optional argument that allows you to specify the value of this within the callback function. It is used to set the context or scope in which the callback function will be executed. If thisArg is provided, it will be used as the value of
Returns Deque<EM, RM>
a new Deque object with elements of type EM and raw elements of type RM.
Overrides LinearBase.map
- Defined in queue/deque.ts:846

pop

pop(): undefined | E
Time Complexity: O(1) Space Complexity: O(1)

The pop() function removes and returns the last element from a data structure, updating the internal state variables accordingly.

Returns undefined | E
The element that was removed from the data structure is being returned.
- Defined in queue/deque.ts:249

print

print(): void
Time Complexity: O(n) Space Complexity: O(n)

The print function logs the elements of an array to the console.

Returns void
Inherited from LinearBase.print
- Defined in base/iterable-element-base.ts:214

push

push(element): boolean
Time Complexity - Amortized O(1) (possible reallocation), Space Complexity - O(n) (due to potential resizing).

The push function adds an element to a data structure and reallocates memory if necessary.
Parameters
- element: E
  The element parameter represents the value that you want to add to the data structure.
Returns boolean
The size of the data structure after the element has been pushed.
Overrides LinearBase.push
- Defined in queue/deque.ts:222

pushMany

pushMany(elements): boolean[]
Time Complexity: O(k) Space Complexity: O(k)

The function pushMany iterates over elements and pushes them into an array after applying a transformation function if provided.
Parameters
- elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>
  The elements parameter in the pushMany function is expected to be an iterable containing elements of type E or R. It can be either an IterableWithSizeOrLength<E> or an IterableWithSizeOrLength<R>. The function iterates over each element
Returns boolean[]
The pushMany function is returning an array of boolean values, where each value represents the result of calling the push method on the current object instance with the corresponding element from the input elements iterable.
Overrides LinearBase.pushMany
- Defined in queue/deque.ts:337

reduce

reduce(callbackfn): E
Parameters
- callbackfn: ReduceElementCallback<E, R>
Returns E
Inherited from LinearBase.reduce
- Defined in base/iterable-element-base.ts:161
reduce(callbackfn, initialValue): E
Parameters
- callbackfn: ReduceElementCallback<E, R>
- initialValue: E
Returns E
Inherited from LinearBase.reduce
- Defined in base/iterable-element-base.ts:162
reduce<U>(callbackfn, initialValue): U
Type Parameters
- U
Parameters
- callbackfn: ReduceElementCallback<E, R, U>
- initialValue: U
Returns U
Inherited from LinearBase.reduce
- Defined in base/iterable-element-base.ts:163

reduceRight

reduceRight(callbackfn): E
Parameters
- callbackfn: ReduceLinearCallback<E>
Returns E
Inherited from LinearBase.reduceRight
- Defined in base/linear-base.ts:270
reduceRight(callbackfn, initialValue): E
Parameters
- callbackfn: ReduceLinearCallback<E>
- initialValue: E
Returns E
Inherited from LinearBase.reduceRight
- Defined in base/linear-base.ts:272
reduceRight<U>(callbackfn, initialValue): U
Type Parameters
- U
Parameters
- callbackfn: ReduceLinearCallback<E, U>
- initialValue: U
Returns U
Inherited from LinearBase.reduceRight
- Defined in base/linear-base.ts:274

reverse

reverse(): this
Time Complexity: O(n) Space Complexity: O(1)

The reverse() function reverses the order of the buckets and the elements within each bucket in a data structure.

Returns this
The reverse() method is returning the object itself (this) after performing the reverse operation on the buckets and updating the relevant properties.
Overrides LinearBase.reverse
- Defined in queue/deque.ts:712

setAt

setAt(pos, element): boolean
Time Complexity: O(1) Space Complexity: O(1)

The setAt function sets an element at a specific position in an array-like data structure.
Parameters
- pos: number
  The pos parameter represents the position at which the element needs to be set. It is of type number.
- element: E
  The element parameter is the value that you want to set at the specified position in the data structure.
Returns boolean
Overrides LinearBase.setAt
- Defined in queue/deque.ts:425

shift

shift(): undefined | E
Time Complexity: O(1) Space Complexity: O(1)

The shift() function removes and returns the first element from a data structure, updating the internal state variables accordingly.

Returns undefined | E
The element that is being removed from the beginning of the data structure is being returned.
- Defined in queue/deque.ts:276

shrinkToFit

shrinkToFit(): void
Time Complexity: O(n) Space Complexity: O(n)

The shrinkToFit function reorganizes the elements in an array-like data structure to minimize memory usage.

Returns void
Nothing is being returned. The function is using the return statement to exit early if this._length is 0, but it does not return any value.
- Defined in queue/deque.ts:758

slice

slice(start?, end?): this
Time Complexity: O(m) Space Complexity: O(m)

The slice function in TypeScript creates a new instance by extracting a portion of elements from the original instance based on the specified start and end indices.
Parameters
- Optionalstart: number = 0
  The start parameter in the slice method represents the index at which to begin extracting elements from an array-like object. If no start parameter is provided, the default value is 0, meaning the extraction will start from the beginning of the array.
- end: number = ...
  The end parameter in the slice method represents the index at which to end the slicing. By default, if no end parameter is provided, it will slice until the end of the array (i.e., this.length).
Returns this
The slice method is returning a new instance of the object with elements sliced from the specified start index (default is 0) to the specified end index (default is the length of the object).
Inherited from LinearBase.slice
- Defined in base/linear-base.ts:315

some

some(predicate, thisArg?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The "some" function checks if at least one element in a collection satisfies a given predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter is a callback function that takes three arguments: value, index, and array. It should return a boolean value indicating whether the current element satisfies the condition.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as the this value when executing the predicate function. If thisArg is provided, it will be passed as the this value to the predicate function. If `thisArg
Returns boolean
a boolean value. It returns true if the predicate function returns true for any element in the collection, and false otherwise.
Inherited from LinearBase.some
- Defined in base/iterable-element-base.ts:86

sort

sort(compareFn?): this
Time Complexity: O(n log n) Space Complexity: O(n)

The sort function in TypeScript sorts the elements of a collection using a specified comparison function.
Parameters
- OptionalcompareFn: ((a: E, b: E) => number)
  The compareFn parameter is a function that defines the sort order. It takes two elements a and b as input and returns a number indicating their relative order. If the returned value is negative, a comes before b. If the returned value is positive, @returns Thesort` method is returning the instance of the object on which it is called (this), after sorting the elements based on the provided comparison function (compareFn).
  - - (a, b): number
    - Parameters
      a: E
      b: E
      Returns number
Returns this
Inherited from LinearBase.sort
- Defined in base/linear-base.ts:183

splice

splice(start, deleteCount?, ...items): this
Time Complexity: O(n) Space Complexity: O(1)

The splice function in TypeScript overrides the default behavior to remove and insert elements in a Deque data structure while ensuring the starting position and delete count are within bounds.
Parameters
- start: number
  The start parameter in the splice method represents the index at which to start changing the array. Items will be removed or added starting from this index.
- deleteCount: number = ...
  The deleteCount parameter in the splice method represents the number of elements to remove from the array starting at the specified start index. If deleteCount is not provided, it defaults to the number of elements from the start index to the end of the array (@param {E[]} items - Theitemsparameter in thesplicemethod represents the elements that will be inserted into the deque at the specifiedstartindex. These elements will be inserted in place of the elements that are removed based on thestartanddeleteCountparameters. @returns Thesplicemethod is returning the arraydeletedElements` which contains the elements that were removed from the Deque during the splice operation.
- Rest...items: E[]
Returns this
Overrides LinearBase.splice
- Defined in queue/deque.ts:521

toArray

toArray(): E[]
Time Complexity: O(n) Space Complexity: O(n)

The toArray function converts a linked list into an array.

Returns E[]
The toArray() method is returning an array of type E[].
Inherited from LinearBase.toArray
- Defined in base/iterable-element-base.ts:194

toReversedArray

toReversedArray(): E[]
Time Complexity: O(n) Space Complexity: O(n)

The function toReversedArray takes an array and returns a new array with its elements in reverse order.

Returns E[]
The toReversedArray() function returns an array of elements of type E in reverse order.
Inherited from LinearBase.toReversedArray
- Defined in base/linear-base.ts:262

toVisual

toVisual(): E[]
Time Complexity: O(n) Space Complexity: O(n)

The print function logs the elements of an array to the console.

Returns E[]
Inherited from LinearBase.toVisual
- Defined in base/iterable-element-base.ts:204

unique

unique(): this
Time Complexity: O(n) Space Complexity: O(1)

The unique() function removes duplicate elements from an array-like data structure and returns the number of unique elements.

Returns this
The size of the modified array is being returned.
- Defined in queue/deque.ts:732

unshift

unshift(element): boolean
Time Complexity: Amortized O(1) Space Complexity: O(n)

The unshift function adds an element to the beginning of an array-like data structure and returns the new size of the structure.
Parameters
- element: E
  The element parameter represents the element that you want to add to the beginning of the data structure.
Returns boolean
The size of the data structure after the element has been added.
- Defined in queue/deque.ts:304

unshiftMany

unshiftMany(elements?): boolean[]
Time Complexity: O(k) Space Complexity: O(k)

The unshiftMany function in TypeScript iterates over elements and adds them to the beginning of an array, optionally converting them using a provided function.
Parameters
- elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = []
  The elements parameter in the unshiftMany function is an iterable containing elements of type E or R. It can be an array or any other iterable data structure that has a known size or length. The function iterates over each element in the elements iterable and
Returns boolean[]
The unshiftMany function returns an array of boolean values indicating whether each element was successfully added to the beginning of the array.
- Defined in queue/deque.ts:362

values

values(): IterableIterator<E, any, any>
Time Complexity: O(n) Space Complexity: O(n)

The function returns an iterator that yields all the values in the object.

Returns IterableIterator<E, any, any>
Inherited from LinearBase.values
- Defined in base/iterable-element-base.ts:42

Class Deque<E, R>

Example

Example

Type Parameters

Hierarchy

Index

Constructors

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns Deque<E, R>

Accessors

first

Returns undefined | E

last

Returns undefined | E

Methods

Protected_createInstance

Parameters

Returns this

Protected_getBucketAndPosition

Parameters

Returns { bucketIndex: number; indexInBucket: number; }

bucketIndex: number

indexInBucket: number

Protected_getIterator

Returns IterableIterator<E, any, any>

Protected_getReverseIterator

Returns IterableIterator<E, any, any>

Protected_reallocate

Parameters

Returns void

[iterator]

Parameters

Returns IterableIterator<E, any, any>

addAt

Parameters

Returns boolean

at

Parameters

Returns E

clear

Returns void

clone

Returns this

concat

Parameters

Returns this

cut

Parameters

Returns Deque<E, any>

cutRest

Parameters

Returns Deque<E, any>

delete

Parameters

Returns boolean

deleteAt

Parameters

Returns undefined | E

every

Parameters

Returns boolean

fill

Parameters

Returns this

filter

Parameters

Returns Deque<E, R>

find

Type Parameters

Parameters

Returns undefined | S

Parameters

Returns undefined | E

findIndex

Parameters

`Protected`_createInstance

`Protected`_getBucketAndPosition

Returns {
bucketIndex: number;
indexInBucket: number;
}

`Protected`_getIterator

`Protected`_getReverseIterator

`Protected`_reallocate