min-heap-typed 1.50.5 → 1.50.7

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/types/common.d.ts

@@ -52,3 +52,9 @@ export type BinaryTreeDeleteResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null | undefined;
 };
+export declare enum CRUD {
+    CREATED = "CREATED",
+    READ = "READ",
+    UPDATED = "UPDATED",
+    DELETED = "DELETED"
+}

package/dist/types/common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
+exports.CRUD = exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
 var BSTVariant;
 (function (BSTVariant) {
     BSTVariant["STANDARD"] = "STANDARD";
@@ -33,3 +33,10 @@ var FamilyPosition;
     FamilyPosition["ISOLATED"] = "ISOLATED";
     FamilyPosition["MAL_NODE"] = "MAL_NODE";
 })(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
+var CRUD;
+(function (CRUD) {
+    CRUD["CREATED"] = "CREATED";
+    CRUD["READ"] = "READ";
+    CRUD["UPDATED"] = "UPDATED";
+    CRUD["DELETED"] = "DELETED";
+})(CRUD = exports.CRUD || (exports.CRUD = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.50.5",
+  "version": "1.50.7",
   "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.7"
   }
 }

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -83,6 +83,10 @@ export class AVLTreeMultiMap<
    * @returns the sum of the count property of all nodes in the tree.
    */
   get count(): number {
+    return this._count;
+  }
+
+  getMutableCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -414,7 +418,7 @@ export class AVLTreeMultiMap<
    * @returns The method is returning the result of calling the `_replaceNode` method from the
    * superclass, after updating the `count` property of the `newNode` object.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);
   }

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

@@ -522,7 +522,7 @@ export class AVLTree<
    * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
    * `oldNode` and `newNode` as arguments.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.height = oldNode.height;
 
     return super._replaceNode(oldNode, newNode);

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;
         }
@@ -1021,11 +1021,11 @@ export class BinaryTree<
    */
   getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
     beginRoot = this.ensureNode(beginRoot);
-    if (!beginRoot) return -1;
+    if (!this.isRealNode(beginRoot)) return -1;
 
     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);
       }
@@ -1073,8 +1073,8 @@ export class BinaryTree<
 
     if (iterationType === IterationType.RECURSIVE) {
       const _getMinHeight = (cur: NODE | null | undefined): number => {
-        if (!cur) return 0;
-        if (!cur.left && !cur.right) return 0;
+        if (!this.isRealNode(cur)) return 0;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
         const leftMinHeight = _getMinHeight(cur.left);
         const rightMinHeight = _getMinHeight(cur.right);
         return Math.min(leftMinHeight, rightMinHeight) + 1;
@@ -1088,16 +1088,16 @@ export class BinaryTree<
       const depths: Map<NODE, number> = new Map();
 
       while (stack.length > 0 || node) {
-        if (node) {
+        if (this.isRealNode(node)) {
           stack.push(node);
           node = node.left;
         } else {
           node = stack[stack.length - 1];
-          if (!node.right || last === node.right) {
+          if (!this.isRealNode(node.right) || last === node.right) {
             node = stack.pop();
-            if (node) {
-              const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
-              const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
+            if (this.isRealNode(node)) {
+              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) ?? -1 : -1;
+              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) ?? -1 : -1;
               depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
               last = node;
               node = null;
@@ -1169,9 +1169,10 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
 
-    if (!beginRoot) return beginRoot;
+    if (!this.isRealNode(beginRoot)) return beginRoot;
 
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (cur: NODE): NODE => {
@@ -1215,6 +1216,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return beginRoot;
@@ -1354,34 +1356,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));
             }
 
@@ -1837,7 +1839,7 @@ export class BinaryTree<
    * following types:
    * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
    */
-  print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
+  override print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
     const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return;

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

@@ -426,14 +426,14 @@ export class BST<
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
   override getNodeByKey(key: K, iterationType = IterationType.ITERATIVE): NODE | undefined {
-    if (!this.root) return undefined;
+    if (!this.isRealNode(this.root)) return undefined;
     if (iterationType === IterationType.RECURSIVE) {
       const _dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
 
-        if (this._compare(cur.key, key) === CP.gt && cur.left) return _dfs(cur.left);
-        if (this._compare(cur.key, key) === CP.lt && cur.right) return _dfs(cur.right);
+        if (this._compare(cur.key, key) === CP.gt && this.isRealNode(cur.left)) return _dfs(cur.left);
+        if (this._compare(cur.key, key) === CP.lt && this.isRealNode(cur.right)) return _dfs(cur.right);
       };
 
       return _dfs(this.root);
@@ -441,10 +441,10 @@ export class BST<
       const queue = new Queue<NODE>([this.root]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           if (this._compare(cur.key, key) === CP.eq) return cur;
-          if (this._compare(cur.key, key) === CP.gt) cur.left && queue.push(cur.left);
-          if (this._compare(cur.key, key) === CP.lt) cur.right && queue.push(cur.right);
+          if (this._compare(cur.key, key) === CP.gt) this.isRealNode(cur.left) && queue.push(cur.left);
+          if (this._compare(cur.key, key) === CP.lt) this.isRealNode(cur.right) && queue.push(cur.right);
         }
       }
     }
@@ -497,14 +497,14 @@ export class BST<
           if (onlyOne) return;
         }
 
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
         if (callback === this._defaultOneParamCallback) {
-          if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && _traverse(cur.left);
-          if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && _traverse(cur.right);
+          if (this._compare(cur.key, identifier as K) === CP.gt) this.isRealNode(cur.left) && _traverse(cur.left);
+          if (this._compare(cur.key, identifier as K) === CP.lt) this.isRealNode(cur.right) && _traverse(cur.right);
         } else {
-          cur.left && _traverse(cur.left);
-          cur.right && _traverse(cur.right);
+          this.isRealNode(cur.left) && _traverse(cur.left);
+          this.isRealNode(cur.right) && _traverse(cur.right);
         }
       };
 
@@ -513,7 +513,7 @@ export class BST<
       const queue = new Queue<NODE>([beginRoot]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           const callbackResult = callback(cur);
           if (callbackResult === identifier) {
             ans.push(cur);
@@ -521,11 +521,11 @@ export class BST<
           }
           // TODO potential bug
           if (callback === this._defaultOneParamCallback) {
-            if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && queue.push(cur.left);
-            if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && queue.push(cur.right);
+            if (this._compare(cur.key, identifier as K) === CP.gt) this.isRealNode(cur.left) && queue.push(cur.left);
+            if (this._compare(cur.key, identifier as K) === CP.lt) this.isRealNode(cur.right) && queue.push(cur.right);
           } else {
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            this.isRealNode(cur.left) && queue.push(cur.left);
+            this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
       }
@@ -856,7 +856,7 @@ export class BST<
    * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
    * can either be an object of type `NODE` or it can be `undefined`.
    */
-  protected _setRoot(v: NODE | undefined) {
+  protected override _setRoot(v: NODE | undefined) {
     if (v) {
       v.parent = undefined;
     }