min-heap-typed 1.50.5 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.50.5",
+  "version": "1.50.6",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.4"
+    "data-structure-typed": "^1.50.6"
   }
 }

package/src/data-structures/binary-tree/binary-tree.ts

@@ -934,7 +934,7 @@ export class BinaryTree<
 
     if (iterationType === IterationType.RECURSIVE) {
       const dfs = (cur: NODE | null | undefined, min: number, max: number): boolean => {
-        if (!cur) return true;
+        if (!this.isRealNode(cur)) return true;
         const numKey = this.extractor(cur.key);
         if (numKey <= min || numKey >= max) return false;
         return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
@@ -949,14 +949,14 @@ export class BinaryTree<
         let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
         // @ts-ignore
         let curr: NODE | null | undefined = beginRoot;
-        while (curr || stack.length > 0) {
-          while (curr) {
+        while (this.isRealNode(curr) || stack.length > 0) {
+          while (this.isRealNode(curr)) {
             stack.push(curr);
             curr = curr.left;
           }
           curr = stack.pop()!;
           const numKey = this.extractor(curr.key);
-          if (!curr || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey)) return false;
+          if (!this.isRealNode(curr) || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey)) return false;
           prev = numKey;
           curr = curr.right;
         }
@@ -1025,7 +1025,7 @@ export class BinaryTree<
 
     if (iterationType === IterationType.RECURSIVE) {
       const _getMaxHeight = (cur: NODE | null | undefined): number => {
-        if (!cur) return -1;
+        if (!this.isRealNode(cur)) return -1;
         const leftHeight = _getMaxHeight(cur.left);
         const rightHeight = _getMaxHeight(cur.right);
         return Math.max(leftHeight, rightHeight) + 1;
@@ -1039,8 +1039,8 @@ export class BinaryTree<
       while (stack.length > 0) {
         const { node, depth } = stack.pop()!;
 
-        if (node.left) stack.push({ node: node.left, depth: depth + 1 });
-        if (node.right) stack.push({ node: node.right, depth: depth + 1 });
+        if (this.isRealNode(node.left)) stack.push({ node: node.left, depth: depth + 1 });
+        if (this.isRealNode(node.right)) stack.push({ node: node.right, depth: depth + 1 });
 
         maxHeight = Math.max(maxHeight, depth);
       }
@@ -1354,34 +1354,34 @@ export class BinaryTree<
         switch (pattern) {
           case 'in':
             if (includeNull) {
-              if (node && this.isNodeOrNull(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               this.isNodeOrNull(node) && ans.push(callback(node));
-              if (node && this.isNodeOrNull(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
             } else {
-              if (node && node.left) _traverse(node.left);
+              if (this.isRealNode(node) && this.isRealNode(node.left)) _traverse(node.left);
               this.isRealNode(node) && ans.push(callback(node));
-              if (node && node.right) _traverse(node.right);
+              if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
           case 'pre':
             if (includeNull) {
               this.isNodeOrNull(node) && ans.push(callback(node));
-              if (node && this.isNodeOrNull(node.left)) _traverse(node.left);
-              if (node && this.isNodeOrNull(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
             } else {
               this.isRealNode(node) && ans.push(callback(node));
-              if (node && node.left) _traverse(node.left);
-              if (node && node.right) _traverse(node.right);
+              if (this.isRealNode(node) && this.isRealNode(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
           case 'post':
             if (includeNull) {
-              if (node && this.isNodeOrNull(node.left)) _traverse(node.left);
-              if (node && this.isNodeOrNull(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
               this.isNodeOrNull(node) && ans.push(callback(node));
             } else {
-              if (node && node.left) _traverse(node.left);
-              if (node && node.right) _traverse(node.right);
+              if (this.isRealNode(node) && this.isRealNode(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
               this.isRealNode(node) && ans.push(callback(node));
             }