data-structure-typed 1.50.3 → 1.50.4

package/dist/umd/data-structure-typed.js

@@ -102,6 +102,8 @@ var dataStructureTyped = (() => {
   var src_exports = {};
   __export(src_exports, {
     AVLTree: () => AVLTree,
+    AVLTreeMultiMap: () => AVLTreeMultiMap,
+    AVLTreeMultiMapNode: () => AVLTreeMultiMapNode,
     AVLTreeNode: () => AVLTreeNode,
     AbstractEdge: () => AbstractEdge,
     AbstractGraph: () => AbstractGraph,
@@ -152,8 +154,8 @@ var dataStructureTyped = (() => {
     SkipListNode: () => SkipListNode,
     Stack: () => Stack,
     THUNK_SYMBOL: () => THUNK_SYMBOL,
-    TreeMultimap: () => TreeMultimap,
-    TreeMultimapNode: () => TreeMultimapNode,
+    TreeMultiMap: () => TreeMultiMap,
+    TreeMultiMapNode: () => TreeMultiMapNode,
     TreeNode: () => TreeNode,
     Trie: () => Trie,
     TrieNode: () => TrieNode,
@@ -10221,11 +10223,9 @@ var dataStructureTyped = (() => {
           const compared = this._compare(cur.key, targetKey);
           if (compared === lesserOrGreater)
             ans.push(callback(cur));
-          if (!cur.left && !cur.right)
-            return;
-          if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+          if (this.isRealNode(cur.left))
             _traverse(cur.left);
-          if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+          if (this.isRealNode(cur.right))
             _traverse(cur.right);
         };
         _traverse(this.root);
@@ -10234,13 +10234,13 @@ var dataStructureTyped = (() => {
         const queue = new Queue([this.root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
+          if (this.isRealNode(cur)) {
             const compared = this._compare(cur.key, targetKey);
             if (compared === lesserOrGreater)
               ans.push(callback(cur));
-            if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+            if (this.isRealNode(cur.left))
               queue.push(cur.left);
-            if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+            if (this.isRealNode(cur.right))
               queue.push(cur.right);
           }
         }
@@ -11847,12 +11847,12 @@ var dataStructureTyped = (() => {
      */
     _fixInsert(k) {
       let u;
-      while (k.parent && k.parent.color === 1) {
+      while (k.parent && k.parent.color === 1 /* RED */) {
         if (k.parent.parent && k.parent === k.parent.parent.right) {
           u = k.parent.parent.left;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
+          if (u && u.color === 1 /* RED */) {
             k.parent.color = 0 /* BLACK */;
+            u.color = 0 /* BLACK */;
             k.parent.parent.color = 1 /* RED */;
             k = k.parent.parent;
           } else {
@@ -11860,15 +11860,17 @@ var dataStructureTyped = (() => {
               k = k.parent;
               this._rightRotate(k);
             }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
+            if (k.parent.color === 1 /* RED */) {
+              k.parent.color = 0 /* BLACK */;
+              k.parent.parent.color = 1 /* RED */;
+            }
             this._leftRotate(k.parent.parent);
           }
         } else {
           u = k.parent.parent.right;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
+          if (u && u.color === 1 /* RED */) {
             k.parent.color = 0 /* BLACK */;
+            u.color = 0 /* BLACK */;
             k.parent.parent.color = 1 /* RED */;
             k = k.parent.parent;
           } else {
@@ -11876,8 +11878,10 @@ var dataStructureTyped = (() => {
               k = k.parent;
               this._leftRotate(k);
             }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
+            if (k.parent.color === 1 /* RED */) {
+              k.parent.color = 0 /* BLACK */;
+              k.parent.parent.color = 1 /* RED */;
+            }
             this._rightRotate(k.parent.parent);
           }
         }
@@ -11996,8 +12000,8 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/binary-tree/tree-multimap.ts
-  var TreeMultimapNode = class extends AVLTreeNode {
+  // src/data-structures/binary-tree/avl-tree-multi-map.ts
+  var AVLTreeMultiMapNode = class extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -12029,7 +12033,7 @@ var dataStructureTyped = (() => {
       this._count = value;
     }
   };
-  var TreeMultimap = class _TreeMultimap extends AVLTree {
+  var AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
@@ -12057,19 +12061,19 @@ var dataStructureTyped = (() => {
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key, value, count) {
-      return new TreeMultimapNode(key, value, count);
+      return new AVLTreeMultiMapNode(key, value, count);
     }
     /**
-     * The function creates a new TreeMultimap object with the specified options and returns it.
+     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `TreeMultimap` object. It can include properties such as
+     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
      * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
      * the tree, respectively. These properties can be
-     * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
      * default options. The returned value is casted as `TREE`.
      */
     createTree(options) {
-      return new _TreeMultimap([], __spreadValues({
+      return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         variant: this.variant
       }, options));
@@ -12106,13 +12110,13 @@ var dataStructureTyped = (() => {
       return node;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
      * class.
      */
     isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof TreeMultimapNode;
+      return keyOrNodeOrEntry instanceof AVLTreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -12344,6 +12348,372 @@ var dataStructureTyped = (() => {
     }
   };
 
+  // src/data-structures/binary-tree/tree-multi-map.ts
+  var TreeMultiMapNode = class extends RedBlackTreeNode {
+    /**
+     * The constructor function initializes an instance of a class with a key, value, and count.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
+     * constructor. It is required and must be provided when creating an instance of the class.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
+     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
+     * 1.
+     */
+    constructor(key, value, count = 1) {
+      super(key, value);
+      __publicField(this, "_count", 1);
+      this.count = count;
+    }
+    /**
+     * The function returns the value of the private variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+      return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+      this._count = value;
+    }
+  };
+  var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
+    /**
+     * The constructor function initializes a new instance of the TreeMultiMap class with optional
+     * initial keys, nodes, or entries.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain keys, nodes, or entries. It is used to initialize the TreeMultiMap with the provided keys,
+     * nodes, or entries.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It allows you to customize the behavior of the `TreeMultiMap` instance.
+     */
+    constructor(keysOrNodesOrEntries = [], options) {
+      super([], options);
+      __publicField(this, "_count", 0);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
+    }
+    // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree structure.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    get count() {
+      let sum = 0;
+      this.dfs((node) => sum += node.count);
+      return sum;
+    }
+    /**
+     * 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,
+     * which is a generic type that can be replaced with any specific type when using the function.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the node. It is of type `V`, which can be any data type.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
+     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
+     * default to 1.
+     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     */
+    createNode(key, value, count) {
+      return new TreeMultiMapNode(key, value, count);
+    }
+    /**
+     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultiMap`. It can include properties such as
+     * `keyComparator`, `valueComparator`, `allowDuplicates`, etc.
+     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+     * existing `iterationType` option. The returned value is casted as `TREE`.
+     */
+    createTree(options) {
+      return new _TreeMultiMap([], __spreadValues({
+        iterationType: this.iterationType
+      }, options));
+    }
+    /**
+     * The function `keyValueOrEntryToNode` takes a key, value, and count and returns a node if the input
+     * is valid.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`. It can accept three types of values:
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @param [count=1] - The count parameter is an optional parameter that specifies the number of times
+     * the key-value pair should be added to the node. If not provided, it defaults to 1.
+     * @returns a NODE object or undefined.
+     */
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
+      let node;
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+        return;
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value2, count);
+        }
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, count);
+      } else {
+        return;
+      }
+      return node;
+    }
+    /**
+     * The function "isNode" checks if a given key, node, or entry is an instance of the TreeMultiMapNode
+     * class.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntry` is an instance
+     * of the `TreeMultiMapNode` class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof TreeMultiMapNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the add method in TypeScript and adds a new node to the data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * data structure.
+     * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
+     * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
+     * be added once. However, you can specify a different value for `count` if you want to add
+     * @returns a boolean value.
+     */
+    add(keyOrNodeOrEntry, value, count = 1) {
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+      if (newNode === void 0)
+        return false;
+      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const inserted = super.add(newNode);
+      if (inserted) {
+        this._count += orgNodeCount;
+      }
+      return true;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function in a TypeScript class is used to delete nodes from a binary tree based on a
+     * given identifier, and it returns an array of results containing information about the deleted
+     * nodes.
+     * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value used
+     * to identify the node to be deleted. It can be of any type that is returned by the callback
+     * function. It can also be null or undefined if no node needs to be deleted.
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
+     * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
+     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * used
+     * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
+     * node when performing deletion. If set to true, the count of the target node will not be considered
+     * and the node will be deleted regardless of its count. If set to false (default), the count of the
+     * target node will be decremented
+     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+     */
+    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+      const deleteResults = [];
+      if (identifier === null)
+        return deleteResults;
+      const deleteHelper = (node) => {
+        let targetNode = this._Sentinel;
+        let currentNode;
+        while (node !== this._Sentinel) {
+          if (node && callback(node) === identifier) {
+            targetNode = node;
+          }
+          if (node && identifier && callback(node) <= identifier) {
+            node = node.right;
+          } else {
+            node = node == null ? void 0 : node.left;
+          }
+        }
+        if (targetNode === this._Sentinel) {
+          return;
+        }
+        if (ignoreCount || targetNode.count <= 1) {
+          let parentNode = targetNode;
+          let parentNodeOriginalColor = parentNode.color;
+          if (targetNode.left === this._Sentinel) {
+            currentNode = targetNode.right;
+            this._rbTransplant(targetNode, targetNode.right);
+          } else if (targetNode.right === this._Sentinel) {
+            currentNode = targetNode.left;
+            this._rbTransplant(targetNode, targetNode.left);
+          } else {
+            parentNode = this.getLeftMost(targetNode.right);
+            parentNodeOriginalColor = parentNode.color;
+            currentNode = parentNode.right;
+            if (parentNode.parent === targetNode) {
+              currentNode.parent = parentNode;
+            } else {
+              this._rbTransplant(parentNode, parentNode.right);
+              parentNode.right = targetNode.right;
+              parentNode.right.parent = parentNode;
+            }
+            this._rbTransplant(targetNode, parentNode);
+            parentNode.left = targetNode.left;
+            parentNode.left.parent = parentNode;
+            parentNode.color = targetNode.color;
+          }
+          if (parentNodeOriginalColor === 0 /* BLACK */) {
+            this._fixDelete(currentNode);
+          }
+          this._size--;
+          this._count -= targetNode.count;
+          deleteResults.push({ deleted: targetNode, needBalanced: void 0 });
+        } else {
+          targetNode.count--;
+          this._count--;
+        }
+      };
+      deleteHelper(this.root);
+      return deleteResults;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function overrides the parent class's "clear" function and also resets the count to
+     * zero.
+     */
+    clear() {
+      super.clear();
+      this._count = 0;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      if (sorted.length < 1)
+        return false;
+      this.clear();
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const buildBalanceBST = (l, r) => {
+          if (l > r)
+            return;
+          const m = l + Math.floor((r - l) / 2);
+          const midNode = sorted[m];
+          this.add(midNode.key, midNode.value, midNode.count);
+          buildBalanceBST(l, m - 1);
+          buildBalanceBST(m + 1, r);
+        };
+        buildBalanceBST(0, n - 1);
+        return true;
+      } else {
+        const stack = [[0, n - 1]];
+        while (stack.length > 0) {
+          const popped = stack.pop();
+          if (popped) {
+            const [l, r] = popped;
+            if (l <= r) {
+              const m = l + Math.floor((r - l) / 2);
+              const midNode = sorted[m];
+              this.add(midNode.key, midNode.value, midNode.count);
+              stack.push([m + 1, r]);
+              stack.push([l, m - 1]);
+            }
+          }
+        }
+        return true;
+      }
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the clone method to create a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this.bfs((node) => cloned.add(node.key, node.value, node.count));
+      return cloned;
+    }
+    /**
+     * The function swaps the properties of two nodes in a binary search tree.
+     * @param srcNode - The source node that needs to be swapped with the destination node. It can be
+     * either a key or a node object.
+     * @param destNode - The `destNode` parameter is the node in the binary search tree where the
+     * properties will be swapped with the `srcNode`.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     * If both `srcNode` and `destNode` are valid nodes, the method swaps their `key`, `value`, `count`,
+     * and `color` properties. If the swapping is successful, the method returns the modified `destNode`.
+     * If either `srcNode` or `destNode` is
+     */
+    _swapProperties(srcNode, destNode) {
+      srcNode = this.ensureNode(srcNode);
+      destNode = this.ensureNode(destNode);
+      if (srcNode && destNode) {
+        const { key, value, count, color } = destNode;
+        const tempNode = this.createNode(key, value, count);
+        if (tempNode) {
+          tempNode.color = color;
+          destNode.key = srcNode.key;
+          destNode.value = srcNode.value;
+          destNode.count = srcNode.count;
+          destNode.color = srcNode.color;
+          srcNode.key = tempNode.key;
+          srcNode.value = tempNode.value;
+          srcNode.count = tempNode.count;
+          srcNode.color = tempNode.color;
+        }
+        return destNode;
+      }
+      return void 0;
+    }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
+    _replaceNode(oldNode, newNode) {
+      newNode.count = oldNode.count + newNode.count;
+      return super._replaceNode(oldNode, newNode);
+    }
+  };
+
   // src/data-structures/tree/tree.ts
   var TreeNode = class _TreeNode {
     /**