min-heap-typed 1.45.3 → 1.46.2

package/dist/data-structures/queue/deque.d.ts

@@ -5,38 +5,157 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { DoublyLinkedList } from '../linked-list';
-export declare class Deque<E = any> extends DoublyLinkedList<E> {
+import { IterableWithSizeOrLength, IterateDirection } from "../../types";
+/**
+ * Deque can provide random access with O(1) time complexity
+ * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
+ * Deque may experience performance jitter, but DoublyLinkedList will not
+ * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
+ */
+export declare class DequeIterator<E> {
+    iterateDirection: IterateDirection;
+    index: number;
+    readonly deque: Deque<E>;
+    /**
+     * The constructor initializes the index, iterate direction, and prev/next functions for a
+     * DequeIterator object.
+     * @param {number} index - The index parameter represents the current index position of the iterator
+     * within the deque. It is a number that indicates the position of the element that the iterator is
+     * currently pointing to.
+     * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
+     * double-ended queue data structure, which allows elements to be added or removed from both ends.
+     * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
+     * the direction in which the iterator should iterate over the elements of the `deque`. It has a
+     * default value of `IterateDirection.DEFAULT`.
+     * @returns The constructor is not returning anything. It is used to initialize the properties of the
+     * object being created.
+     */
+    constructor(index: number, deque: Deque<E>, iterateDirection?: IterateDirection);
+    get current(): E;
+    set current(newElement: E);
+    isAccessible(): boolean;
+    prev(): DequeIterator<E>;
+    next(): DequeIterator<E>;
+    clone(): DequeIterator<E>;
 }
-export declare class ObjectDeque<E = number> {
-    constructor(capacity?: number);
-    protected _nodes: {
-        [key: number]: E;
-    };
-    get nodes(): {
-        [p: number]: E;
-    };
-    protected _capacity: number;
-    get capacity(): number;
-    protected _first: number;
-    get first(): number;
-    protected _last: number;
-    get last(): number;
+export declare class Deque<E> {
+    protected _bucketFirst: number;
+    protected _firstInBucket: number;
+    protected _bucketLast: number;
+    protected _lastInBucket: number;
+    protected _bucketCount: number;
+    protected readonly _bucketSize: number;
+    /**
+     * The constructor initializes a data structure with a specified bucket size and populates it with
+     * elements from an iterable.
+     * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
+     * contains the initial elements to be stored in the data structure. It can also be an object with a
+     * `length` property or a `size` property, which represents the number of elements in the iterable.
+     * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
+     * stored in each bucket. It determines the size of each bucket in the data structure.
+     */
+    constructor(elements?: IterableWithSizeOrLength<E>, bucketSize?: number);
+    protected _buckets: E[][];
+    get buckets(): E[][];
     protected _size: number;
     get size(): number;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * The function returns the first element in a collection if it exists, otherwise it returns
+     * undefined.
+     * @returns The first element of the collection, of type E, is being returned.
+     */
+    get first(): E | undefined;
+    get last(): E | undefined;
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty(): boolean;
+    /**
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
      */
     /**
      * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
      *
-     * The "addFirst" function adds a value to the beginning of an array-like data structure.
-     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * The addLast function adds an element to the end of an array.
+     * @param {E} element - The element parameter represents the element that you want to add to the end of the
+     * data structure.
+     */
+    addLast(element: E): void;
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     */
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     *
+     * The function "popLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
+     */
+    popLast(): E | undefined;
+    /**
+     * Time Complexity: O(1).
+     * Space Complexity: O(n) - Due to potential resizing.
+     *
+     * The "addFirst" function adds an element to the beginning of an array.
+     * @param {E} element - The parameter "element" represents the element that you want to add to the
+     * beginning of the data structure.
+     */
+    addFirst(element: E): void;
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     *
+     * The function "popFirst" removes and returns the first element of an array.
+     * @returns The method `popFirst()` is returning the first element of the array after removing it
+     * from the beginning. If the array is empty, it will return `undefined`.
+     */
+    popFirst(): E | undefined;
+    /**
+     * The clear() function resets the state of the object by initializing all variables to their default
+     * values.
+     */
+    clear(): void;
+    /**
+     * The `begin()` function returns a new iterator for a deque starting from the first element.
+     * @returns A new instance of the DequeIterator class is being returned.
+     */
+    begin(): DequeIterator<E>;
+    /**
+     * The `end()` function returns a new `DequeIterator` object with the size and reference to the
+     * current deque.
+     * @returns A new instance of the DequeIterator class is being returned.
+     */
+    end(): DequeIterator<E>;
+    /**
+     * The reverseBegin function returns a new DequeIterator object that starts at the last element of
+     * the deque and iterates in reverse direction.
+     * @returns A new instance of the DequeIterator class is being returned.
+     */
+    reverseBegin(): DequeIterator<E>;
+    /**
+     * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
+     * Deque in reverse order.
+     * @returns A new instance of the DequeIterator class is being returned.
+     */
+    reverseEnd(): DequeIterator<E>;
+    /**
+     * Time Complexity - Amortized O(1) (possible reallocation)
+     * Space Complexity - O(n) (due to potential resizing).
+     */
+    /**
+     * 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.
+     * @param {E} element - The `element` parameter represents the value that you want to add to the data
      * structure.
+     * @returns The size of the data structure after the element has been pushed.
      */
-    addFirst(value: E): void;
+    push(element: E): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -45,10 +164,26 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The addLast function adds a value to the end of an array-like data structure.
-     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     * The `pop()` function removes and returns the last element from a data structure, updating the
+     * internal state variables accordingly.
+     * @returns The element that was removed from the data structure is being returned.
      */
-    addLast(value: E): void;
+    pop(): E | undefined;
+    /**
+     * Time Complexity: Amortized O(1)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the
+     * beginning of the data structure.
+     * @returns The size of the data structure after the element has been added.
+     */
+    unshift(element: E): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -57,10 +192,12 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `popFirst()` removes and returns the first element in a data structure.
-     * @returns The value of the first element in the data structure.
+     * The `shift()` function removes and returns the first element from a data structure, updating the
+     * internal state variables accordingly.
+     * @returns The element that is being removed from the beginning of the data structure is being
+     * returned.
      */
-    popFirst(): E | undefined;
+    shift(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -69,10 +206,13 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getFirst` function returns the first element in an array-like data structure if it exists.
-     * @returns The element at the first position of the `_nodes` array.
+     * The `getAt` function retrieves an element at a specified position in an array-like data structure.
+     * @param {number} pos - 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 The element at the specified position in the data structure is being returned.
      */
-    getFirst(): E | undefined;
+    getAt(pos: number): E;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -81,10 +221,33 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popLast()` function removes and returns the last element in a data structure.
-     * @returns The value that was removed from the data structure.
+     * The `setAt` function sets an element at a specific position in an array-like data structure.
+     * @param {number} pos - The `pos` parameter represents the position at which the element needs to be
+     * set. It is of type `number`.
+     * @param {E} element - The `element` parameter is the value that you want to set at the specified
+     * position in the data structure.
      */
-    popLast(): E | undefined;
+    setAt(pos: number, element: E): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `insertAt` function inserts one or more elements at a specified position in an array-like data
+     * structure.
+     * @param {number} pos - The `pos` parameter represents the position at which the element(s) should
+     * be inserted. It is of type `number`.
+     * @param {E} element - The `element` parameter represents the element that you want to insert into
+     * the array at the specified position.
+     * @param [num=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 The size of the array after the insertion is being returned.
+     */
+    insertAt(pos: number, element: E, num?: number): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -93,60 +256,142 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getLast()` function returns the last element in an array-like data structure.
-     * @returns The last element in the array "_nodes" is being returned.
+     * The `cut` function updates the state of the object based on the given position and returns the
+     * updated size.
+     * @param {number} pos - 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.
+     * @returns The method is returning the updated size of the data structure.
      */
-    getLast(): E | undefined;
+    cut(pos: number): number;
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The get function returns the element at the specified index in an array-like data structure.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `null` is returned.
+     * The `deleteAt` function removes an element at a specified position in an array-like data
+     * structure.
+     * @param {number} pos - 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 The size of the data structure after the deletion operation is performed.
      */
-    get(index: number): NonNullable<E> | null;
+    deleteAt(pos: number): number;
     /**
-     * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
-    isEmpty(): boolean;
-}
-export declare class ArrayDeque<E> {
-    protected _nodes: E[];
-    get nodes(): E[];
-    get size(): number;
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function removes all occurrences of a specified element from an array-like data
+     * structure.
+     * @param {E} element - The `element` parameter represents the element that you want to delete from
+     * the data structure.
+     * @returns The size of the data structure after the element has been deleted.
+     */
+    delete(element: E): number;
+    /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function "addLast" adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
-     * @returns The return value is the new length of the array after the value has been added.
+     * The function deletes an element from a deque using an iterator and returns the next iterator.
+     * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
+     * that is used to iterate over elements in a deque (double-ended queue).
+     * @returns the updated iterator after deleting an element from the deque.
      */
-    addLast(value: E): number;
+    deleteByIterator(iter: DequeIterator<E>): DequeIterator<E>;
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
+     * the element if found, otherwise it returns an iterator pointing to the end of the deque.
+     * @param {E} element - The `element` parameter is the element that you want to find in the deque.
+     * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
+     */
+    findIterator(element: E): DequeIterator<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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 The reverse() method is returning the object itself (this) after performing the reverse
+     * operation on the buckets and updating the relevant properties.
+     */
+    reverse(): this;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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 The size of the modified array is being returned.
+     */
+    unique(): number;
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `sort` function sorts the elements in a data structure using a provided comparator function.
+     * @param [comparator] - The `comparator` parameter is a function that takes in two elements `x` and
+     * `y` of type `E` and returns a number. The comparator function is used to determine the order of
+     * the elements in the sorted array.
+     * @returns The method is returning the sorted instance of the object on which the method is called.
+     */
+    sort(comparator?: (x: E, y: E) => number): this;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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 Nothing is being returned. The function is using the `return` statement to exit early if
+     * `this.size` is 0, but it does not return any value.
+     */
+    shrinkToFit(): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
-     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     * The `forEach` function iterates over each element in a deque and applies a callback function to
+     * each element.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three parameters:
      */
-    popLast(): E | null;
+    forEach(callback: (element: E, index: number, deque: Deque<E>) => void): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -155,11 +400,74 @@ export declare class ArrayDeque<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
-     * empty.
+     * The `find` function iterates over the elements in a deque and returns the first element for which
+     * the callback function returns true, or undefined if no such element is found.
+     * @param callback - A function that takes three parameters: element, index, and deque. It should
+     * return a boolean value indicating whether the element satisfies a certain condition.
+     * @returns The method `find` returns the first element in the deque that satisfies the condition
+     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
+     */
+    find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `toArray` function converts the elements of a data structure into an array.
+     * @returns The `toArray()` method is returning an array of elements of type `E`.
+     */
+    toArray(): E[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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.
+     * @param callback - The `callback` parameter is a function that takes three arguments:
+     * @returns The `map` method is returning a new `Deque` object with the transformed elements.
      */
-    popFirst(): E | null;
+    map<T>(callback: (element: E, index: number, deque: Deque<E>) => T): Deque<T>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new deque containing only the elements that satisfy the given
+     * predicate function.
+     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
+     * `index`, and `deque`.
+     * @returns The `filter` method is returning a new `Deque` object that contains only the elements
+     * that satisfy the given `predicate` function.
+     */
+    filter(predicate: (element: E, index: number, deque: Deque<E>) => boolean): Deque<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reduce` function iterates over the elements of a deque and applies a callback function to
+     * each element, accumulating a single value.
+     * @param callback - The `callback` parameter is a function that takes four arguments:
+     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the `callback` function when reducing
+     * the elements of the deque.
+     * @returns the final value of the accumulator after iterating over all elements in the deque and
+     * applying the callback function to each element.
+     */
+    reduce<T>(callback: (accumulator: T, element: E, index: number, deque: Deque<E>) => T, initialValue: T): T;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -168,12 +476,40 @@ export declare class ArrayDeque<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function "addFirst" adds a value to the beginning of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
-     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
-     * `value` at the beginning.
+     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
+     * or -1 if the element is not found.
+     * @param {E} element - The "element" parameter represents the element that you want to find the
+     * index of in the data structure.
+     * @returns The indexOf function returns the index of the first occurrence of the specified element
+     * in the data structure. If the element is not found, it returns -1.
      */
-    addFirst(value: E): number;
+    indexOf(element: E): number;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `_reallocate` function reallocates the buckets in an array, adding new buckets if needed.
+     * @param {number} [needBucketNum] - 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.
+     */
+    protected _reallocate(needBucketNum?: number): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -182,11 +518,45 @@ export declare class ArrayDeque<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
-     * empty, it will return `null`.
+     * The function calculates the bucket index and index within the bucket based on the given position.
+     * @param {number} pos - 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 an object with two properties: "bucketIndex" and "indexInBucket".
+     */
+    protected _getBucketAndPosition(pos: number): {
+        bucketIndex: number;
+        indexInBucket: number;
+    };
+}
+export declare class ObjectDeque<E = number> {
+    constructor(capacity?: number);
+    protected _nodes: {
+        [key: number]: E;
+    };
+    get nodes(): {
+        [p: number]: E;
+    };
+    protected _capacity: number;
+    get capacity(): number;
+    protected _first: number;
+    get first(): number;
+    protected _last: number;
+    get last(): number;
+    protected _size: number;
+    get size(): number;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
-    getFirst(): E | null;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "addFirst" function adds an element to the beginning of an array-like data structure.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
+     * structure.
+     */
+    addFirst(element: E): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -195,10 +565,10 @@ export declare class ArrayDeque<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getLast` function returns the last element of an array or null if the array is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     * The addLast function adds an element to the end of an array-like data structure.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
      */
-    getLast(): E | null;
+    addLast(element: E): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -207,13 +577,10 @@ export declare class ArrayDeque<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
-     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
+     * The function `popFirst()` removes and returns the first element in a data structure.
+     * @returns The element of the first element in the data structure.
      */
-    get(index: number): E | null;
+    popFirst(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -222,50 +589,52 @@ export declare class ArrayDeque<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The set function assigns a value to a specific index in an array.
-     * @param {number} index - The index parameter is a number that represents the position of the element in the array
-     * that you want to set a new value for.
-     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
-     * _nodes array.
-     * @returns The value that is being set at the specified index in the `_nodes` array.
+     * The `getFirst` function returns the first element in an array-like data structure if it exists.
+     * @returns The element at the first position of the `_nodes` array.
      */
-    set(index: number, value: E): E;
+    getFirst(): E | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The insert function adds a value at a specified index in an array.
-     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
-     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
-     * from 0, so the first element of the array has an index of 0, the second element has
-     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
-     * index.
-     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
-     * are being removed, an empty array will be returned.
+     * The `popLast()` function removes and returns the last element in a data structure.
+     * @returns The element that was removed from the data structure.
      */
-    insert(index: number, value: E): E[];
+    popLast(): E | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The delete function removes an element from an array at a specified index.
-     * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
-     * is a number that represents the index of the element to be removed.
-     * @returns The method is returning an array containing the removed element.
+     * The `getLast()` function returns the last element in an array-like data structure.
+     * @returns The last element in the array "_nodes" is being returned.
+     */
+    getLast(): E | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
-    delete(index: number): E[];
     /**
-     * The function checks if an array called "_nodes" is empty.
-     * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
-     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The get function returns the element at the specified index in an array-like data structure.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
+     * index, `undefined` is returned.
+     */
+    get(index: number): NonNullable<E> | undefined;
+    /**
+     * The function checks if the size of a data structure is less than or equal to zero.
+     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty(): boolean;
 }