min-heap-typed 1.50.4 → 1.50.6

package/dist/data-structures/binary-tree/tree-multi-map.d.ts

@@ -51,6 +51,7 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
+    getMutableCount(): number;
     /**
      * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -58,10 +58,12 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
+        return this._count;
+    }
+    getMutableCount() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
         return sum;
-        // return this._count;
     }
     /**
      * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
@@ -154,14 +156,15 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      */
     add(keyOrNodeOrEntry, value, count = 1) {
         const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
-        if (newNode === undefined)
+        const orgCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
+        const isSuccessAdded = super.add(newNode);
+        if (isSuccessAdded) {
+            this._count += orgCount;
+            return true;
+        }
+        else {
             return false;
-        const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
-        const inserted = super.add(newNode);
-        if (inserted) {
-            this._count += orgNodeCount;
         }
-        return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -188,86 +191,91 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
-        const deleteResults = [];
         if (identifier === null)
-            return deleteResults;
-        // Helper function to perform deletion
-        const deleteHelper = (node) => {
-            // Initialize targetNode to the sentinel node
-            let targetNode = this._Sentinel;
-            let currentNode;
-            // Find the node to be deleted based on the identifier
-            while (node !== this._Sentinel) {
-                // Update targetNode if the current node matches the identifier
-                if (node && callback(node) === identifier) {
-                    targetNode = node;
-                }
-                // Move to the right or left based on the comparison with the identifier
-                if (node && identifier && callback(node) <= identifier) {
-                    node = node.right;
-                }
-                else {
-                    node = node === null || node === void 0 ? void 0 : node.left;
-                }
+            return [];
+        const results = [];
+        const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+        if (!nodeToDelete) {
+            return results;
+        }
+        let originalColor = nodeToDelete.color;
+        let replacementNode;
+        if (!this.isRealNode(nodeToDelete.left)) {
+            replacementNode = nodeToDelete.right;
+            if (ignoreCount || nodeToDelete.count <= 1) {
+                this._transplant(nodeToDelete, nodeToDelete.right);
+                this._count -= nodeToDelete.count;
             }
-            // If the target node is not found, decrement size and return
-            if (targetNode === this._Sentinel) {
-                return;
+            else {
+                nodeToDelete.count--;
+                this._count--;
+                results.push({ deleted: nodeToDelete, needBalanced: undefined });
+                return results;
             }
-            if (ignoreCount || targetNode.count <= 1) {
-                // Store the parent of the target node and its original color
-                let parentNode = targetNode;
-                let parentNodeOriginalColor = parentNode.color;
-                // Handle deletion based on the number of children of the target node
-                if (targetNode.left === this._Sentinel) {
-                    // Target node has no left child - deletion case 1
-                    currentNode = targetNode.right;
-                    this._rbTransplant(targetNode, targetNode.right);
-                }
-                else if (targetNode.right === this._Sentinel) {
-                    // Target node has no right child - deletion case 2
-                    currentNode = targetNode.left;
-                    this._rbTransplant(targetNode, targetNode.left);
+        }
+        else if (!this.isRealNode(nodeToDelete.right)) {
+            replacementNode = nodeToDelete.left;
+            if (ignoreCount || nodeToDelete.count <= 1) {
+                this._transplant(nodeToDelete, nodeToDelete.left);
+                this._count -= nodeToDelete.count;
+            }
+            else {
+                nodeToDelete.count--;
+                this._count--;
+                results.push({ deleted: nodeToDelete, needBalanced: undefined });
+                return results;
+            }
+        }
+        else {
+            const successor = this.getLeftMost(nodeToDelete.right);
+            if (successor) {
+                originalColor = successor.color;
+                replacementNode = successor.right;
+                if (successor.parent === nodeToDelete) {
+                    if (this.isRealNode(replacementNode)) {
+                        replacementNode.parent = successor;
+                    }
                 }
                 else {
-                    // Target node has both left and right children - deletion case 3
-                    parentNode = this.getLeftMost(targetNode.right);
-                    parentNodeOriginalColor = parentNode.color;
-                    currentNode = parentNode.right;
-                    if (parentNode.parent === targetNode) {
-                        // Target node's right child becomes its parent's left child
-                        currentNode.parent = parentNode;
+                    if (ignoreCount || nodeToDelete.count <= 1) {
+                        this._transplant(successor, successor.right);
+                        this._count -= nodeToDelete.count;
                     }
                     else {
-                        // Replace parentNode with its right child and update connections
-                        this._rbTransplant(parentNode, parentNode.right);
-                        parentNode.right = targetNode.right;
-                        parentNode.right.parent = parentNode;
+                        nodeToDelete.count--;
+                        this._count--;
+                        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+                        return results;
+                    }
+                    successor.right = nodeToDelete.right;
+                    if (this.isRealNode(successor.right)) {
+                        successor.right.parent = successor;
                     }
-                    // Replace the target node with its in-order successor
-                    this._rbTransplant(targetNode, parentNode);
-                    parentNode.left = targetNode.left;
-                    parentNode.left.parent = parentNode;
-                    parentNode.color = targetNode.color;
                 }
-                // Fix the Red-Black Tree properties after deletion
-                if (parentNodeOriginalColor === types_1.RBTNColor.BLACK) {
-                    this._fixDelete(currentNode);
+                if (ignoreCount || nodeToDelete.count <= 1) {
+                    this._transplant(nodeToDelete, successor);
+                    this._count -= nodeToDelete.count;
                 }
-                // Decrement the size and store information about the deleted node
-                this._size--;
-                this._count -= targetNode.count;
-                deleteResults.push({ deleted: targetNode, needBalanced: undefined });
-            }
-            else {
-                targetNode.count--;
-                this._count--;
+                else {
+                    nodeToDelete.count--;
+                    this._count--;
+                    results.push({ deleted: nodeToDelete, needBalanced: undefined });
+                    return results;
+                }
+                successor.left = nodeToDelete.left;
+                if (this.isRealNode(successor.left)) {
+                    successor.left.parent = successor;
+                }
+                successor.color = nodeToDelete.color;
             }
-        };
-        // Call the helper function with the root of the tree
-        deleteHelper(this.root);
-        // Return the result array
-        return deleteResults;
+        }
+        this._size--;
+        // If the original color was black, fix the tree
+        if (originalColor === types_1.RBTNColor.BLACK) {
+            this._deleteFixup(replacementNode);
+        }
+        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+        return results;
     }
     /**
      * Time Complexity: O(1)

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -41,6 +41,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     protected _vertexMap: Map<VertexKey, VO>;
     get vertexMap(): Map<VertexKey, VO>;
     set vertexMap(v: Map<VertexKey, VO>);
+    get size(): number;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.

package/dist/data-structures/graph/abstract-graph.js

@@ -50,6 +50,9 @@ class AbstractGraph extends base_1.IterableEntryBase {
     set vertexMap(v) {
         this._vertexMap = v;
     }
+    get size() {
+        return this._vertexMap.size;
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.

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

@@ -131,24 +131,19 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The push function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
+     * The push function adds a new element to the end of a doubly linked list.
+     * @param {E} element - The "element" parameter represents the value that you want to add to the
+     * doubly linked list.
+     * @returns The `push` method is returning a boolean value, `true`.
      */
-    push(value: E): boolean;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
+     * The `pop()` function removes and returns the value of the last element in a linked list.
+     * @returns The method is returning the value of the removed node.
      */
     pop(): E | undefined;
     /**
@@ -156,12 +151,8 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `shift()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
+     * The `shift()` function removes and returns the value of the first element in a doubly linked list.
+     * @returns The value of the removed node.
      */
     shift(): E | undefined;
     /**
@@ -169,14 +160,12 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
+     * The unshift function adds a new element to the beginning of a doubly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the beginning of the doubly linked list.
+     * @returns The `unshift` method is returning a boolean value, `true`.
      */
-    unshift(value: E): boolean;
+    unshift(element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -449,57 +438,6 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * object.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): DoublyLinkedList<T>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
-     */
-    addLast(value: E): boolean;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
-     */
-    pollLast(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(value: E): void;
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

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

@@ -161,14 +161,13 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The push function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
+     * The push function adds a new element to the end of a doubly linked list.
+     * @param {E} element - The "element" parameter represents the value that you want to add to the
+     * doubly linked list.
+     * @returns The `push` method is returning a boolean value, `true`.
      */
-    push(value) {
-        const newNode = new DoublyLinkedListNode(value);
+    push(element) {
+        const newNode = new DoublyLinkedListNode(element);
         if (!this.head) {
             this._head = newNode;
             this._tail = newNode;
@@ -186,12 +185,8 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
+     * The `pop()` function removes and returns the value of the last element in a linked list.
+     * @returns The method is returning the value of the removed node.
      */
     pop() {
         if (!this.tail)
@@ -213,12 +208,8 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `shift()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
+     * The `shift()` function removes and returns the value of the first element in a doubly linked list.
+     * @returns The value of the removed node.
      */
     shift() {
         if (!this.head)
@@ -240,15 +231,13 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
+     * The unshift function adds a new element to the beginning of a doubly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the beginning of the doubly linked list.
+     * @returns The `unshift` method is returning a boolean value, `true`.
      */
-    unshift(value) {
-        const newNode = new DoublyLinkedListNode(value);
+    unshift(element) {
+        const newNode = new DoublyLinkedListNode(element);
         if (!this.head) {
             this._head = newNode;
             this._tail = newNode;
@@ -738,65 +727,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return mappedList;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
-     */
-    addLast(value) {
-        return this.push(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
-     */
-    pollLast() {
-        return this.pop();
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst() {
-        return this.shift();
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(value) {
-        this.unshift(value);
-    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

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

@@ -60,6 +60,18 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The method is returning either a SinglyLinkedListNode object or undefined.
      */
     get tail(): SinglyLinkedListNode<E> | undefined;
+    /**
+     * The above function returns the value of the first element in a linked list, or undefined if the
+     * list is empty.
+     * @returns The value of the first node in the linked list, or undefined if the linked list is empty.
+     */
+    get first(): E | undefined;
+    /**
+     * The function returns the value of the last element in a linked list, or undefined if the list is
+     * empty.
+     * @returns The value of the last node in the linked list, or undefined if the linked list is empty.
+     */
+    get last(): E | undefined;
     protected _size: number;
     /**
      * The function returns the size of an object.
@@ -82,21 +94,6 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
     static fromArray<E>(data: E[]): SinglyLinkedList<E>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     * Constant time, as it involves basic pointer adjustments.
-     * Constant space, as it only creates a new node.
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `push` function adds a new node with the given value to the end of a singly linked list.
-     * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
-     * any type (E) as specified in the generic type declaration of the class or function.
-     */
-    push(value: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -105,11 +102,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `push` function adds a new node with the given value to the end of a singly linked list.
-     * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
-     * any type (E) as specified in the generic type declaration of the class or function.
+     * The push function adds a new element to the end of a singly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the linked list.
+     * @returns The `push` method is returning a boolean value, `true`.
      */
-    addLast(value: E): boolean;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -119,26 +117,11 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
-     * pointers accordingly.
-     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-     * the linked list is empty, it returns `undefined`.
+     * The `pop` function removes and returns the value of the last element in a linked list.
+     * @returns The method is returning the value of the element that is being popped from the end of the
+     * list.
      */
     pop(): E | undefined;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
-     * pointers accordingly.
-     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-     * the linked list is empty, it returns `undefined`.
-     */
-    pollLast(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -147,8 +130,8 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `shift()` function removes and returns the value of the first node in a linked list.
-     * @returns The value of the node that is being removed from the beginning of the linked list.
+     * The `shift()` function removes and returns the value of the first element in a linked list.
+     * @returns The value of the removed node.
      */
     shift(): E | undefined;
     /**
@@ -159,40 +142,15 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `pollFirst()` function removes and returns the value of the first node in a linked list.
-     * @returns The value of the node that is being removed from the beginning of the linked list.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The unshift function adds a new node with the given value to the beginning of a singly linked list.
-     * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
-     * linked list.
-     */
-    unshift(value: E): boolean;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
-     * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
-     * linked list.
+     * The unshift function adds a new element to the beginning of a singly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the beginning of the singly linked list.
+     * @returns The `unshift` method is returning a boolean value, `true`.
      */
-    addFirst(value: E): boolean;
+    unshift(element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      */
     /**
      * Time Complexity: O(n)