data-structure-typed 1.49.1 → 1.49.2

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

@@ -73,95 +73,6 @@ export class Deque extends 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).
@@ -194,7 +105,7 @@ export class Deque extends IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketLast][this._lastInBucket] = element;
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -261,7 +172,7 @@ export class Deque extends IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketFirst][this._firstInBucket] = element;
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -296,6 +207,44 @@ export class Deque extends 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)
@@ -333,6 +282,7 @@ export class Deque extends IterableElementBase {
         rangeCheck(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._buckets[bucketIndex][indexInBucket] = element;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -342,7 +292,7 @@ export class Deque extends 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`.
@@ -353,7 +303,7 @@ export class Deque extends 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;
         rangeCheck(pos, 0, length);
         if (pos === 0) {
@@ -375,7 +325,7 @@ export class Deque extends IterableElementBase {
             for (let i = 0; i < arr.length; ++i)
                 this.push(arr[i]);
         }
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -434,7 +384,7 @@ export class Deque extends IterableElementBase {
             }
             this.pop();
         }
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -453,7 +403,7 @@ export class Deque extends IterableElementBase {
     delete(element) {
         const size = this.size;
         if (size === 0)
-            return 0;
+            return false;
         let i = 0;
         let index = 0;
         while (i < size) {
@@ -465,7 +415,7 @@ export class Deque extends IterableElementBase {
             i += 1;
         }
         this.cut(index - 1);
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -505,7 +455,7 @@ export class Deque extends IterableElementBase {
      */
     unique() {
         if (this.size <= 1) {
-            return this.size;
+            return this;
         }
         let index = 1;
         let prev = this.getAt(0);
@@ -517,7 +467,7 @@ export class Deque extends IterableElementBase {
             }
         }
         this.cut(index - 1);
-        return this.size;
+        return this;
     }
     /**
      * Time Complexity: O(n log n)
@@ -531,7 +481,7 @@ export class Deque extends 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 = [];
@@ -602,7 +552,7 @@ export class Deque extends IterableElementBase {
                 return element;
             }
         }
-        return undefined;
+        return;
     }
     /**
      * Time Complexity: O(n)
@@ -639,11 +589,7 @@ export class Deque extends 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)
@@ -703,11 +649,55 @@ export class Deque extends 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)

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

@@ -53,7 +53,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
      * @returns The `add` method is returning a `Queue<E>` object.
      */
-    push(element: E): Queue<E>;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -75,11 +75,11 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
-    getFirst(): E | undefined;
+    get first(): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -101,11 +101,11 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
+     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
-    getLast(): E | undefined;
+    get last(): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -130,7 +130,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    enqueue(value: E): Queue<E>;
+    enqueue(value: E): boolean;
     /**
      * Time Complexity: O(n) - same as shift().
      * Space Complexity: O(1) - same as shift().
@@ -194,7 +194,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone(): Queue<E>;
-    print(): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -239,7 +238,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
 }
 /**
  * 1. First In, First Out (FIFO) Strategy: Like other queue implementations, LinkedListQueue follows the first in, first out principle, meaning the element that is added to the queue first will be the first to be removed.
@@ -252,17 +251,17 @@ export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
      * The enqueue function 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 queue.
      */
-    enqueue(value: E): void;
+    enqueue(value: E): boolean;
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
      * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
      */
     dequeue(): E | undefined;
     /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    getFirst(): E | undefined;
+    get first(): E | undefined;
     /**
      * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.

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

@@ -61,7 +61,7 @@ export class Queue extends IterableElementBase {
      */
     push(element) {
         this.nodes.push(element);
-        return this;
+        return true;
     }
     /**
      * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
@@ -78,7 +78,7 @@ export class Queue extends IterableElementBase {
     shift() {
         if (this.size === 0)
             return undefined;
-        const first = this.getFirst();
+        const first = this.first;
         this._offset += 1;
         if (this.offset * 2 < this.nodes.length)
             return first;
@@ -96,11 +96,11 @@ export class Queue extends IterableElementBase {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
-    getFirst() {
+    get first() {
         return this.size > 0 ? this.nodes[this.offset] : undefined;
     }
     /**
@@ -116,7 +116,7 @@ export class Queue extends IterableElementBase {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
-        return this.getFirst();
+        return this.first;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -126,11 +126,11 @@ export class Queue extends IterableElementBase {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
+     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
-    getLast() {
+    get last() {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
     }
     /**
@@ -146,7 +146,7 @@ export class Queue extends IterableElementBase {
      * array is empty, it returns `undefined`.
      */
     peekLast() {
-        return this.getLast();
+        return this.last;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -238,9 +238,6 @@ export class Queue extends IterableElementBase {
     clone() {
         return new Queue(this.nodes.slice(this.offset));
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -321,7 +318,7 @@ export class LinkedListQueue extends SinglyLinkedList {
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
-        this.push(value);
+        return this.push(value);
     }
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
@@ -331,10 +328,10 @@ export class LinkedListQueue extends SinglyLinkedList {
         return this.shift();
     }
     /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    getFirst() {
+    get first() {
         return this.head?.value;
     }
     /**
@@ -342,6 +339,6 @@ export class LinkedListQueue extends SinglyLinkedList {
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
     peek() {
-        return this.getFirst();
+        return this.first;
     }
 }

package/dist/mjs/data-structures/stack/stack.d.ts

@@ -73,7 +73,7 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
      * @returns The `push` method is returning the updated `Stack<E>` object.
      */
-    push(element: E): Stack<E>;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -154,10 +154,9 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @returns The `map` method is returning a new `Stack` object.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
-    print(): void;
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
 }

package/dist/mjs/data-structures/stack/stack.js

@@ -87,7 +87,7 @@ export class Stack extends IterableElementBase {
      */
     push(element) {
         this.elements.push(element);
-        return this;
+        return true;
     }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
@@ -103,7 +103,7 @@ export class Stack extends IterableElementBase {
      */
     pop() {
         if (this.isEmpty())
-            return undefined;
+            return;
         return this.elements.pop();
     }
     /**
@@ -197,9 +197,6 @@ export class Stack extends IterableElementBase {
         }
         return newStack;
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.

package/dist/mjs/data-structures/trie/trie.d.ts

@@ -172,7 +172,7 @@ export declare class Trie extends IterableElementBase<string> {
      * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
-    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): string[];
+    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): Trie;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -191,7 +191,6 @@ export declare class Trie extends IterableElementBase<string> {
      * @returns The `map` function is returning a new Trie object.
      */
     map(callback: ElementCallback<string, string>, thisArg?: any): Trie;
-    print(): void;
     protected _getIterator(): IterableIterator<string>;
     /**
      * Time Complexity: O(M), where M is the length of the input string.

package/dist/mjs/data-structures/trie/trie.js

@@ -343,11 +343,11 @@ export class Trie extends IterableElementBase {
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
     filter(predicate, thisArg) {
-        const results = [];
+        const results = new Trie();
         let index = 0;
         for (const word of this) {
             if (predicate.call(thisArg, word, index, this)) {
-                results.push(word);
+                results.add(word);
             }
             index++;
         }
@@ -379,9 +379,6 @@ export class Trie extends IterableElementBase {
         }
         return newTrie;
     }
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         function* _dfs(node, path) {
             if (node.isEnd) {