graph-typed 1.45.3 → 1.46.1

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

@@ -5,8 +5,126 @@
  * @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>;
+    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 Deque<E> {
+    protected _bucketFirst: number;
+    protected _firstInBucket: number;
+    protected _bucketLast: number;
+    protected _lastInBucket: number;
+    protected _bucketCount: number;
+    protected readonly _bucketSize: number;
+    constructor(elements?: IterableWithSizeOrLength<E>, bucketSize?: number);
+    protected _buckets: E[][];
+    get buckets(): E[][];
+    protected _size: number;
+    get size(): number;
+    get first(): E | undefined;
+    get last(): E | undefined;
+    /**
+     * Time Complexity: Amortized O(1) - Generally constant time, but resizing when the deque is full leads to O(n).
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     */
+    empty(): boolean;
+    /**
+     * 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(n) - In worst case, resizing doubles the array size.
+     *
+     * 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;
+    clear(): void;
+    begin(): DequeIterator<E>;
+    end(): DequeIterator<E>;
+    reverseBegin(): DequeIterator<E>;
+    reverseEnd(): DequeIterator<E>;
+    push(element: E): number;
+    pop(): E | undefined;
+    unshift(element: E): number;
+    shift(): E | undefined;
+    getAt(pos: number): E;
+    setAt(pos: number, element: E): void;
+    insertAt(pos: number, element: E, num?: number): number;
+    cut(pos: number): number;
+    deleteAt(pos: number): number;
+    delete(element: E): number;
+    deleteByIterator(iter: DequeIterator<E>): DequeIterator<E>;
+    findIterator(element: E): DequeIterator<E>;
+    reverse(): this;
+    unique(): number;
+    sort(comparator?: (x: E, y: E) => number): this;
+    shrinkToFit(): void;
+    forEach(callback: (element: E, index: number, deque: Deque<E>) => void): void;
+    find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined;
+    toArray(): E[];
+    map<T>(callback: (element: E, index: number, deque: Deque<E>) => T): Deque<T>;
+    filter(predicate: (element: E, index: number, deque: Deque<E>) => boolean): Deque<E>;
+    reduce<T>(callback: (accumulator: T, element: E, index: number, deque: Deque<E>) => T, initialValue: T): T;
+    indexOf(element: E): number;
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    protected _reallocate(needBucketNum?: number): void;
+    protected _getBucketAndPosition(pos: number): {
+        bucketIndex: number;
+        indexInBucket: number;
+    };
 }
 export declare class ObjectDeque<E = number> {
     constructor(capacity?: number);
@@ -32,11 +150,11 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * 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 "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(value: E): void;
+    addFirst(element: E): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -45,10 +163,10 @@ 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 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.
      */
-    addLast(value: E): void;
+    addLast(element: E): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -58,7 +176,7 @@ export declare class ObjectDeque<E = number> {
      * 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.
+     * @returns The element of the first element in the data structure.
      */
     popFirst(): E | undefined;
     /**
@@ -82,7 +200,7 @@ export declare class ObjectDeque<E = number> {
      * 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.
+     * @returns The element that was removed from the data structure.
      */
     popLast(): E | undefined;
     /**
@@ -109,163 +227,12 @@ export declare class ObjectDeque<E = number> {
      * @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.
+     * index, `undefined` is returned.
      */
-    get(index: number): NonNullable<E> | null;
+    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 value indicating whether the size of the object is less than or equal to 0.
-     */
-    isEmpty(): boolean;
-}
-export declare class ArrayDeque<E> {
-    protected _nodes: E[];
-    get nodes(): E[];
-    get size(): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * 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.
-     */
-    addLast(value: E): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * 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.
-     */
-    popLast(): E | null;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * 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.
-     */
-    popFirst(): E | null;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * 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.
-     */
-    addFirst(value: E): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * 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`.
-     */
-    getFirst(): E | null;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * 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.
-     */
-    getLast(): E | null;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * 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.
-     */
-    get(index: number): E | null;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * 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.
-     */
-    set(index: number, value: E): E;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * 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.
-     */
-    insert(index: number, value: E): E[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * 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.
-     */
-    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`.
+     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty(): boolean;
 }