data-structure-typed 1.50.5 → 1.50.6

package/dist/mjs/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/mjs/data-structures/binary-tree/tree-multi-map.js

@@ -54,10 +54,12 @@ export class TreeMultiMap extends 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.
@@ -153,14 +155,15 @@ export class TreeMultiMap extends RedBlackTree {
      */
     add(keyOrNodeOrEntry, value, count = 1) {
         const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
-        if (newNode === undefined)
+        const orgCount = newNode?.count || 0;
+        const isSuccessAdded = super.add(newNode);
+        if (isSuccessAdded) {
+            this._count += orgCount;
+            return true;
+        }
+        else {
             return false;
-        const orgNodeCount = newNode?.count || 0;
-        const inserted = super.add(newNode);
-        if (inserted) {
-            this._count += orgNodeCount;
         }
-        return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -187,86 +190,91 @@ export class TreeMultiMap extends 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?.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 === 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 === RBTNColor.BLACK) {
+            this._deleteFixup(replacementNode);
+        }
+        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+        return results;
     }
     /**
      * Time Complexity: O(1)