stack-typed 1.49.1 → 1.49.2

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -22,7 +22,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         super();
         this._head = undefined;
         this._tail = undefined;
-        this._length = 0;
+        this._size = 0;
         if (elements) {
             for (const el of elements)
                 this.push(el);
@@ -34,8 +34,8 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     get tail() {
         return this._tail;
     }
-    get length() {
-        return this._length;
+    get size() {
+        return this._size;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
@@ -79,7 +79,8 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             this.tail.next = newNode;
             this._tail = newNode;
         }
-        this._length++;
+        this._size++;
+        return true;
     }
     /**
      * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
@@ -94,7 +95,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * any type (E) as specified in the generic type declaration of the class or function.
      */
     addLast(value) {
-        this.push(value);
+        return this.push(value);
     }
     /**
      * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
@@ -116,7 +117,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             const value = this.head.value;
             this._head = undefined;
             this._tail = undefined;
-            this._length--;
+            this._size--;
             return value;
         }
         let current = this.head;
@@ -126,7 +127,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         const value = this.tail.value;
         current.next = undefined;
         this._tail = current;
-        this._length--;
+        this._size--;
         return value;
     }
     /**
@@ -161,7 +162,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             return undefined;
         const removedNode = this.head;
         this._head = this.head.next;
-        this._length--;
+        this._size--;
         return removedNode.value;
     }
     /**
@@ -200,7 +201,8 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             newNode.next = this.head;
             this._head = newNode;
         }
-        this._length++;
+        this._size++;
+        return true;
     }
     /**
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
@@ -215,7 +217,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * linked list.
      */
     addFirst(value) {
-        this.unshift(value);
+        return this.unshift(value);
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
@@ -232,7 +234,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * `undefined` if the index is out of bounds.
      */
     getAt(index) {
-        if (index < 0 || index >= this.length)
+        if (index < 0 || index >= this.size)
             return undefined;
         let current = this.head;
         for (let i = 0; i < index; i++) {
@@ -276,17 +278,21 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * bounds.
      */
     deleteAt(index) {
-        if (index < 0 || index >= this.length)
-            return undefined;
-        if (index === 0)
-            return this.shift();
-        if (index === this.length - 1)
-            return this.pop();
+        if (index < 0 || index >= this.size)
+            return false;
+        if (index === 0) {
+            this.shift();
+            return true;
+        }
+        if (index === this.size - 1) {
+            this.pop();
+            return true;
+        }
         const prevNode = this.getNodeAt(index - 1);
         const removedNode = prevNode.next;
         prevNode.next = removedNode.next;
-        this._length--;
-        return removedNode.value;
+        this._size--;
+        return true;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
@@ -327,7 +333,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
                         this._tail = prev;
                     }
                 }
-                this._length--;
+                this._size--;
                 return true;
             }
             prev = current;
@@ -343,7 +349,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAt` function inserts a value at a specified index in a singly linked list.
+     * The `addAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
      * @param {E} value - The `value` parameter represents the value that you want to insert into the linked list at the
@@ -351,14 +357,14 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index, value) {
-        if (index < 0 || index > this.length)
+    addAt(index, value) {
+        if (index < 0 || index > this.size)
             return false;
         if (index === 0) {
             this.unshift(value);
             return true;
         }
-        if (index === this.length) {
+        if (index === this.size) {
             this.push(value);
             return true;
         }
@@ -366,7 +372,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         const prevNode = this.getNodeAt(index - 1);
         newNode.next = prevNode.next;
         prevNode.next = newNode;
-        this._length++;
+        this._size++;
         return true;
     }
     /**
@@ -375,7 +381,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
     isEmpty() {
-        return this.length === 0;
+        return this.size === 0;
     }
     /**
      * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
@@ -383,7 +389,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     clear() {
         this._head = undefined;
         this._tail = undefined;
-        this._length = 0;
+        this._size = 0;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
@@ -418,7 +424,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      */
     reverse() {
         if (!this.head || this.head === this.tail)
-            return;
+            return this;
         let prev = undefined;
         let current = this.head;
         let next = undefined;
@@ -429,6 +435,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             current = next;
         }
         [this._head, this._tail] = [this.tail, this.head];
+        return this;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
@@ -511,14 +518,14 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * The `addBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
      * new value before. It can be either the value itself or a node containing the value in the linked list.
      * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * @returns The method `addBefore` returns a boolean value. It returns `true` if the new value was successfully
      * inserted before the existing value, and `false` otherwise.
      */
-    insertBefore(existingValueOrNode, newValue) {
+    addBefore(existingValueOrNode, newValue) {
         if (!this.head)
             return false;
         let existingValue;
@@ -538,7 +545,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
                 const newNode = new SinglyLinkedListNode(newValue);
                 newNode.next = current.next;
                 current.next = newNode;
-                this._length++;
+                this._size++;
                 return true;
             }
             current = current.next;
@@ -553,14 +560,14 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
      * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
      * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
      * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
      * existing value or node, and false if the existing value or node was not found in the linked list.
      */
-    insertAfter(existingValueOrNode, newValue) {
+    addAfter(existingValueOrNode, newValue) {
         let existingNode;
         if (existingValueOrNode instanceof SinglyLinkedListNode) {
             existingNode = existingValueOrNode;
@@ -575,7 +582,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             if (existingNode === this.tail) {
                 this._tail = newNode;
             }
-            this._length++;
+            this._size++;
             return true;
         }
         return false;
@@ -662,13 +669,6 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         }
         return mappedList;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         let current = this.head;
         while (current) {

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -90,7 +90,7 @@ export declare class SkipList<K, V> {
      * Get the value of the first element (the smallest element) in the Skip List.
      * @returns The value of the first element, or undefined if the Skip List is empty.
      */
-    getFirst(): V | undefined;
+    get first(): V | undefined;
     /**
      * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
@@ -102,7 +102,7 @@ export declare class SkipList<K, V> {
      * Get the value of the last element (the largest element) in the Skip List.
      * @returns The value of the last element, or undefined if the Skip List is empty.
      */
-    getLast(): V | undefined;
+    get last(): V | undefined;
     /**
      * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.

package/dist/data-structures/linked-list/skip-linked-list.js

@@ -158,7 +158,7 @@ class SkipList {
      * Get the value of the first element (the smallest element) in the Skip List.
      * @returns The value of the first element, or undefined if the Skip List is empty.
      */
-    getFirst() {
+    get first() {
         const firstNode = this.head.forward[0];
         return firstNode ? firstNode.value : undefined;
     }
@@ -173,7 +173,7 @@ class SkipList {
      * Get the value of the last element (the largest element) in the Skip List.
      * @returns The value of the last element, or undefined if the Skip List is empty.
      */
-    getLast() {
+    get last() {
         let current = this.head;
         for (let i = this.level - 1; i >= 0; i--) {
             while (current.forward[i]) {

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)