min-heap-typed 1.49.1 → 1.49.3

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

@@ -42,68 +42,6 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     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(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 "pollLast" removes and returns the last element of an array.
-     * @returns The last element of the array is being returned.
-     */
-    pollLast(): 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 "pollFirst" removes and returns the first element of an array.
-     * @returns The method `pollFirst()` is returning the first element of the array after removing it
-     * from the beginning. If the array is empty, it will return `undefined`.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * The clear() function resets the state of the object by initializing all variables to their default
-     * values.
-     */
-    clear(): void;
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    begin(): Generator<E>;
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    reverseBegin(): Generator<E>;
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
      * Space Complexity - O(n) (due to potential resizing).
@@ -117,7 +55,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * structure.
      * @returns The size of the data structure after the element has been pushed.
      */
-    push(element: E): number;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -145,7 +83,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * beginning of the data structure.
      * @returns The size of the data structure after the element has been added.
      */
-    unshift(element: E): number;
+    unshift(element: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -160,6 +98,25 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * returned.
      */
     shift(): E | undefined;
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty(): boolean;
+    /**
+     * The clear() function resets the state of the object by initializing all variables to their default
+     * values.
+     */
+    clear(): void;
+    /**
+     * The below function is a generator that yields elements from a collection one by one.
+     */
+    begin(): Generator<E>;
+    /**
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
+     */
+    reverseBegin(): Generator<E>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -189,7 +146,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @param {E} element - The `element` parameter is the value that you want to set at the specified
      * position in the data structure.
      */
-    setAt(pos: number, element: E): void;
+    setAt(pos: number, element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -198,7 +155,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * 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
+     * The `addAt` 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`.
@@ -209,7 +166,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * 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;
+    addAt(pos: number, element: E, num?: number): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -240,7 +197,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * the index of the element to be deleted.
      * @returns The size of the data structure after the deletion operation is performed.
      */
-    deleteAt(pos: number): number;
+    deleteAt(pos: number): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -255,7 +212,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * the data structure.
      * @returns The size of the data structure after the element has been deleted.
      */
-    delete(element: E): number;
+    delete(element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -282,7 +239,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * the number of unique elements.
      * @returns The size of the modified array is being returned.
      */
-    unique(): number;
+    unique(): this;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -295,7 +252,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @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.
+     * @returns Deque<E>
      */
     sort(comparator?: (x: E, y: E) => number): this;
     /**
@@ -396,10 +353,48 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T>;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * 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): boolean;
+    /**
+     * 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 "pollLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
+     */
+    pollLast(): 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.
      */
-    print(): void;
+    addFirst(element: E): boolean;
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     *
+     * The function "pollFirst" removes and returns the first element of an array.
+     * @returns The method `pollFirst()` is returning the first element of the array after removing it
+     * from the beginning. If the array is empty, it will return `undefined`.
+     */
+    pollFirst(): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -407,7 +402,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * The above function is an implementation of the iterator protocol in TypeScript, allowing the
      * object to be iterated over using a for...of loop.
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/queue/deque.js

@@ -75,95 +75,6 @@ class Deque extends base_1.IterableElementBase {
             return;
         return this._buckets[this._bucketLast][this._lastInBucket];
     }
-    /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
-     */
-    isEmpty() {
-        return this.size === 0;
-    }
-    /**
-     * 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) {
-        this.push(element);
-    }
-    /**
-     * 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 "pollLast" removes and returns the last element of an array.
-     * @returns The last element of the array is being returned.
-     */
-    pollLast() {
-        return this.pop();
-    }
-    /**
-     * 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) {
-        this.unshift(element);
-    }
-    /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
-     *
-     * The function "pollFirst" removes and returns the first element of an array.
-     * @returns The method `pollFirst()` is returning the first element of the array after removing it
-     * from the beginning. If the array is empty, it will return `undefined`.
-     */
-    pollFirst() {
-        return this.shift();
-    }
-    /**
-     * The clear() function resets the state of the object by initializing all variables to their default
-     * values.
-     */
-    clear() {
-        this._buckets = [new Array(this._bucketSize)];
-        this._bucketCount = 1;
-        this._bucketFirst = this._bucketLast = this._size = 0;
-        this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
-    }
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    *begin() {
-        let index = 0;
-        while (index < this.size) {
-            yield this.getAt(index);
-            index++;
-        }
-    }
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    *reverseBegin() {
-        let index = this.size - 1;
-        while (index >= 0) {
-            yield this.getAt(index);
-            index--;
-        }
-    }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
      * Space Complexity - O(n) (due to potential resizing).
@@ -196,7 +107,7 @@ class Deque extends base_1.IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketLast][this._lastInBucket] = element;
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -263,7 +174,7 @@ class Deque extends base_1.IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketFirst][this._firstInBucket] = element;
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -298,6 +209,44 @@ class Deque extends base_1.IterableElementBase {
         this._size -= 1;
         return element;
     }
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * The clear() function resets the state of the object by initializing all variables to their default
+     * values.
+     */
+    clear() {
+        this._buckets = [new Array(this._bucketSize)];
+        this._bucketCount = 1;
+        this._bucketFirst = this._bucketLast = this._size = 0;
+        this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
+    /**
+     * The below function is a generator that yields elements from a collection one by one.
+     */
+    *begin() {
+        let index = 0;
+        while (index < this.size) {
+            yield this.getAt(index);
+            index++;
+        }
+    }
+    /**
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
+     */
+    *reverseBegin() {
+        let index = this.size - 1;
+        while (index >= 0) {
+            yield this.getAt(index);
+            index--;
+        }
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -335,6 +284,7 @@ class Deque extends base_1.IterableElementBase {
         (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._buckets[bucketIndex][indexInBucket] = element;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -344,7 +294,7 @@ class Deque extends base_1.IterableElementBase {
      * 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
+     * The `addAt` 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`.
@@ -355,7 +305,7 @@ class Deque extends base_1.IterableElementBase {
      * 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, element, num = 1) {
+    addAt(pos, element, num = 1) {
         const length = this.size;
         (0, utils_1.rangeCheck)(pos, 0, length);
         if (pos === 0) {
@@ -377,7 +327,7 @@ class Deque extends base_1.IterableElementBase {
             for (let i = 0; i < arr.length; ++i)
                 this.push(arr[i]);
         }
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -436,7 +386,7 @@ class Deque extends base_1.IterableElementBase {
             }
             this.pop();
         }
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -455,7 +405,7 @@ class Deque extends base_1.IterableElementBase {
     delete(element) {
         const size = this.size;
         if (size === 0)
-            return 0;
+            return false;
         let i = 0;
         let index = 0;
         while (i < size) {
@@ -467,7 +417,7 @@ class Deque extends base_1.IterableElementBase {
             i += 1;
         }
         this.cut(index - 1);
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -507,7 +457,7 @@ class Deque extends base_1.IterableElementBase {
      */
     unique() {
         if (this.size <= 1) {
-            return this.size;
+            return this;
         }
         let index = 1;
         let prev = this.getAt(0);
@@ -519,7 +469,7 @@ class Deque extends base_1.IterableElementBase {
             }
         }
         this.cut(index - 1);
-        return this.size;
+        return this;
     }
     /**
      * Time Complexity: O(n log n)
@@ -533,7 +483,7 @@ class Deque extends base_1.IterableElementBase {
      * @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.
+     * @returns Deque<E>
      */
     sort(comparator) {
         const arr = [];
@@ -604,7 +554,7 @@ class Deque extends base_1.IterableElementBase {
                 return element;
             }
         }
-        return undefined;
+        return;
     }
     /**
      * Time Complexity: O(n)
@@ -641,11 +591,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The `toArray()` method is returning an array of elements of type `E`.
      */
     toArray() {
-        const arr = [];
-        for (let i = 0; i < this.size; ++i) {
-            arr.push(this.getAt(i));
-        }
-        return arr;
+        return [...this];
     }
     /**
      * Time Complexity: O(n)
@@ -705,11 +651,55 @@ class Deque extends base_1.IterableElementBase {
         return newDeque;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * 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) {
+        return this.push(element);
+    }
+    /**
+     * 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 "pollLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
      */
-    print() {
-        console.log([...this]);
+    pollLast() {
+        return this.pop();
+    }
+    /**
+     * 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) {
+        return this.unshift(element);
+    }
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     *
+     * The function "pollFirst" removes and returns the first element of an array.
+     * @returns The method `pollFirst()` is returning the first element of the array after removing it
+     * from the beginning. If the array is empty, it will return `undefined`.
+     */
+    pollFirst() {
+        return this.shift();
     }
     /**
      * Time Complexity: O(n)