data-structure-typed 1.50.8 → 1.51.0

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

@@ -139,7 +139,6 @@ var dataStructureTyped = (() => {
     Navigator: () => Navigator,
     PriorityQueue: () => PriorityQueue,
     Queue: () => Queue,
-    RBTNColor: () => RBTNColor,
     RedBlackTree: () => RedBlackTree,
     RedBlackTreeNode: () => RedBlackTreeNode,
     SegmentTree: () => SegmentTree,
@@ -4831,23 +4830,23 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
-     * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order = "pre") {
+    dfs(order = "PRE") {
       const result = [];
       const _dfs = (index) => {
         const left = 2 * index + 1, right = left + 1;
         if (index < this.size) {
-          if (order === "in") {
+          if (order === "IN") {
             _dfs(left);
             result.push(this.elements[index]);
             _dfs(right);
-          } else if (order === "pre") {
+          } else if (order === "PRE") {
             result.push(this.elements[index]);
             _dfs(left);
             _dfs(right);
-          } else if (order === "post") {
+          } else if (order === "POST") {
             _dfs(left);
             _dfs(right);
             result.push(this.elements[index]);
@@ -8707,7 +8706,7 @@ var dataStructureTyped = (() => {
        * `false`, null or undefined
        * @returns an array of values that are the return values of the callback function.
        */
-    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE", includeNull = false) {
+    dfs(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE", includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
@@ -8715,7 +8714,7 @@ var dataStructureTyped = (() => {
       if (iterationType === "RECURSIVE") {
         const _traverse = (node) => {
           switch (pattern) {
-            case "in":
+            case "IN":
               if (includeNull) {
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
@@ -8730,7 +8729,7 @@ var dataStructureTyped = (() => {
                   _traverse(node.right);
               }
               break;
-            case "pre":
+            case "PRE":
               if (includeNull) {
                 this.isNodeOrNull(node) && ans.push(callback(node));
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
@@ -8745,7 +8744,7 @@ var dataStructureTyped = (() => {
                   _traverse(node.right);
               }
               break;
-            case "post":
+            case "POST":
               if (includeNull) {
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
@@ -8780,17 +8779,17 @@ var dataStructureTyped = (() => {
             ans.push(callback(cur.node));
           } else {
             switch (pattern) {
-              case "in":
+              case "IN":
                 cur.node && stack.push({ opt: 0, node: cur.node.right });
                 stack.push({ opt: 1, node: cur.node });
                 cur.node && stack.push({ opt: 0, node: cur.node.left });
                 break;
-              case "pre":
+              case "PRE":
                 cur.node && stack.push({ opt: 0, node: cur.node.right });
                 cur.node && stack.push({ opt: 0, node: cur.node.left });
                 stack.push({ opt: 1, node: cur.node });
                 break;
-              case "post":
+              case "POST":
                 stack.push({ opt: 1, node: cur.node });
                 cur.node && stack.push({ opt: 0, node: cur.node.right });
                 cur.node && stack.push({ opt: 0, node: cur.node.left });
@@ -8974,7 +8973,7 @@ var dataStructureTyped = (() => {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root) {
+    morris(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root) {
       beginRoot = this.ensureNode(beginRoot);
       if (beginRoot === null)
         return [];
@@ -9001,7 +9000,7 @@ var dataStructureTyped = (() => {
         _reverseEdge(tail);
       };
       switch (pattern) {
-        case "in":
+        case "IN":
           while (cur) {
             if (cur.left) {
               const predecessor = this.getPredecessor(cur);
@@ -9017,7 +9016,7 @@ var dataStructureTyped = (() => {
             cur = cur.right;
           }
           break;
-        case "pre":
+        case "PRE":
           while (cur) {
             if (cur.left) {
               const predecessor = this.getPredecessor(cur);
@@ -9035,7 +9034,7 @@ var dataStructureTyped = (() => {
             cur = cur.right;
           }
           break;
-        case "post":
+        case "POST":
           while (cur) {
             if (cur.left) {
               const predecessor = this.getPredecessor(cur);
@@ -9803,7 +9802,7 @@ var dataStructureTyped = (() => {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE") {
+    dfs(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE") {
       return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -9965,7 +9964,7 @@ var dataStructureTyped = (() => {
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
       this.clear();
       if (sorted.length < 1)
         return false;
@@ -10089,11 +10088,28 @@ var dataStructureTyped = (() => {
       const compared = this.variant === "STANDARD" ? extractedA - extractedB : extractedB - extractedA;
       return compared > 0 ? "GT" : compared < 0 ? "LT" : "EQ";
     }
+    /**
+     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
+     * `a` is less than `b` based on the specified variant.
+     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
+     * first value to be compared in the function.
+     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
+     * of the arguments for the comparison in the `_lt` function.
+     * @returns a boolean value.
+     */
     _lt(a, b) {
       const extractedA = this.extractor(a);
       const extractedB = this.extractor(b);
       return this.variant === "STANDARD" ? extractedA < extractedB : extractedA > extractedB;
     }
+    /**
+     * The function compares two values using a custom extractor function and returns true if the first
+     * value is greater than the second value.
+     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
+     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
+     * of the arguments for the comparison in the function.
+     * @returns a boolean value.
+     */
     _gt(a, b) {
       const extractedA = this.extractor(a);
       const extractedB = this.extractor(b);
@@ -11116,13 +11132,6 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/types/data-structures/binary-tree/rb-tree.ts
-  var RBTNColor = /* @__PURE__ */ ((RBTNColor2) => {
-    RBTNColor2[RBTNColor2["RED"] = 1] = "RED";
-    RBTNColor2[RBTNColor2["BLACK"] = 0] = "BLACK";
-    return RBTNColor2;
-  })(RBTNColor || {});
-
   // src/data-structures/binary-tree/rb-tree.ts
   var RedBlackTreeNode = class extends BSTNode {
     /**
@@ -11134,9 +11143,9 @@ var dataStructureTyped = (() => {
      * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
      * creating a new instance of the Red-Black Tree Node.
      * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
      */
-    constructor(key, value, color = 0 /* BLACK */) {
+    constructor(key, value, color = "BLACK") {
       super(key, value);
       __publicField(this, "_color");
       this._color = color;
@@ -11197,12 +11206,12 @@ var dataStructureTyped = (() => {
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the key in the node. It is not required and can be omitted if not needed.
      * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
-     * Red-Black Tree. It is an optional parameter with a default value of "RBTNColor.BLACK". The color
-     * can be either "RBTNColor.RED" or "RBTNColor.BLACK".
+     * Red-Black Tree. It is an optional parameter with a default value of "'BLACK'". The color
+     * can be either "'RED'" or "'BLACK'".
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
-    createNode(key, value, color = 0 /* BLACK */) {
+    createNode(key, value, color = "BLACK") {
       return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -11242,10 +11251,10 @@ var dataStructureTyped = (() => {
         if (key === void 0 || key === null) {
           return;
         } else {
-          node = this.createNode(key, value2, 1 /* RED */);
+          node = this.createNode(key, value2, "RED");
         }
       } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, 1 /* RED */);
+        node = this.createNode(keyOrNodeOrEntry, value, "RED");
       } else {
         return;
       }
@@ -11353,7 +11362,7 @@ var dataStructureTyped = (() => {
       const insertStatus = this._insert(newNode);
       if (insertStatus === "CREATED") {
         if (this.isRealNode(this._root)) {
-          this._root.color = 0 /* BLACK */;
+          this._root.color = "BLACK";
         } else {
           return false;
         }
@@ -11423,7 +11432,7 @@ var dataStructureTyped = (() => {
         }
       }
       this._size--;
-      if (originalColor === 0 /* BLACK */) {
+      if (originalColor === "BLACK") {
         this._deleteFixup(replacementNode);
       }
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
@@ -11500,7 +11509,7 @@ var dataStructureTyped = (() => {
       }
       node.left = this.SENTINEL;
       node.right = this.SENTINEL;
-      node.color = 1 /* RED */;
+      node.color = "RED";
       this._insertFixup(node);
       return "CREATED";
     }
@@ -11543,13 +11552,13 @@ var dataStructureTyped = (() => {
      */
     _insertFixup(z) {
       var _a, _b, _c, _d;
-      while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === 1 /* RED */) {
+      while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === "RED") {
         if (z.parent === ((_b = z.parent.parent) == null ? void 0 : _b.left)) {
           const y = z.parent.parent.right;
-          if ((y == null ? void 0 : y.color) === 1 /* RED */) {
-            z.parent.color = 0 /* BLACK */;
-            y.color = 0 /* BLACK */;
-            z.parent.parent.color = 1 /* RED */;
+          if ((y == null ? void 0 : y.color) === "RED") {
+            z.parent.color = "BLACK";
+            y.color = "BLACK";
+            z.parent.parent.color = "RED";
             z = z.parent.parent;
           } else {
             if (z === z.parent.right) {
@@ -11557,17 +11566,17 @@ var dataStructureTyped = (() => {
               this._leftRotate(z);
             }
             if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-              z.parent.color = 0 /* BLACK */;
-              z.parent.parent.color = 1 /* RED */;
+              z.parent.color = "BLACK";
+              z.parent.parent.color = "RED";
               this._rightRotate(z.parent.parent);
             }
           }
         } else {
           const y = (_d = (_c = z == null ? void 0 : z.parent) == null ? void 0 : _c.parent) == null ? void 0 : _d.left;
-          if ((y == null ? void 0 : y.color) === 1 /* RED */) {
-            z.parent.color = 0 /* BLACK */;
-            y.color = 0 /* BLACK */;
-            z.parent.parent.color = 1 /* RED */;
+          if ((y == null ? void 0 : y.color) === "RED") {
+            z.parent.color = "BLACK";
+            y.color = "BLACK";
+            z.parent.parent.color = "RED";
             z = z.parent.parent;
           } else {
             if (z === z.parent.left) {
@@ -11575,15 +11584,15 @@ var dataStructureTyped = (() => {
               this._rightRotate(z);
             }
             if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-              z.parent.color = 0 /* BLACK */;
-              z.parent.parent.color = 1 /* RED */;
+              z.parent.color = "BLACK";
+              z.parent.parent.color = "RED";
               this._leftRotate(z.parent.parent);
             }
           }
         }
       }
       if (this.isRealNode(this._root))
-        this._root.color = 0 /* BLACK */;
+        this._root.color = "BLACK";
     }
     /**
      * Time Complexity: O(log n)
@@ -11601,66 +11610,66 @@ var dataStructureTyped = (() => {
      */
     _deleteFixup(node) {
       var _a, _b, _c, _d;
-      if (!node || node === this.root || node.color === 0 /* BLACK */) {
+      if (!node || node === this.root || node.color === "BLACK") {
         if (node) {
-          node.color = 0 /* BLACK */;
+          node.color = "BLACK";
         }
         return;
       }
-      while (node && node !== this.root && node.color === 0 /* BLACK */) {
+      while (node && node !== this.root && node.color === "BLACK") {
         const parent = node.parent;
         if (!parent) {
           break;
         }
         if (node === parent.left) {
           let sibling = parent.right;
-          if ((sibling == null ? void 0 : sibling.color) === 1 /* RED */) {
-            sibling.color = 0 /* BLACK */;
-            parent.color = 1 /* RED */;
+          if ((sibling == null ? void 0 : sibling.color) === "RED") {
+            sibling.color = "BLACK";
+            parent.color = "RED";
             this._leftRotate(parent);
             sibling = parent.right;
           }
-          if (((_b = (_a = sibling == null ? void 0 : sibling.left) == null ? void 0 : _a.color) != null ? _b : 0 /* BLACK */) === 0 /* BLACK */) {
+          if (((_b = (_a = sibling == null ? void 0 : sibling.left) == null ? void 0 : _a.color) != null ? _b : "BLACK") === "BLACK") {
             if (sibling)
-              sibling.color = 1 /* RED */;
+              sibling.color = "RED";
             node = parent;
           } else {
             if (sibling == null ? void 0 : sibling.left)
-              sibling.left.color = 0 /* BLACK */;
+              sibling.left.color = "BLACK";
             if (sibling)
               sibling.color = parent.color;
-            parent.color = 0 /* BLACK */;
+            parent.color = "BLACK";
             this._rightRotate(parent);
             node = this.root;
           }
         } else {
           let sibling = parent.left;
-          if ((sibling == null ? void 0 : sibling.color) === 1 /* RED */) {
-            sibling.color = 0 /* BLACK */;
+          if ((sibling == null ? void 0 : sibling.color) === "RED") {
+            sibling.color = "BLACK";
             if (parent)
-              parent.color = 1 /* RED */;
+              parent.color = "RED";
             this._rightRotate(parent);
             if (parent)
               sibling = parent.left;
           }
-          if (((_d = (_c = sibling == null ? void 0 : sibling.right) == null ? void 0 : _c.color) != null ? _d : 0 /* BLACK */) === 0 /* BLACK */) {
+          if (((_d = (_c = sibling == null ? void 0 : sibling.right) == null ? void 0 : _c.color) != null ? _d : "BLACK") === "BLACK") {
             if (sibling)
-              sibling.color = 1 /* RED */;
+              sibling.color = "RED";
             node = parent;
           } else {
             if (sibling == null ? void 0 : sibling.right)
-              sibling.right.color = 0 /* BLACK */;
+              sibling.right.color = "BLACK";
             if (sibling)
               sibling.color = parent.color;
             if (parent)
-              parent.color = 0 /* BLACK */;
+              parent.color = "BLACK";
             this._leftRotate(parent);
             node = this.root;
           }
         }
       }
       if (node) {
-        node.color = 0 /* BLACK */;
+        node.color = "BLACK";
       }
     }
     /**
@@ -11780,7 +11789,19 @@ var dataStructureTyped = (() => {
     get count() {
       return this._count;
     }
-    getMutableCount() {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
       return sum;
@@ -11988,7 +12009,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
       if (sorted.length < 1)
         return false;
       this.clear();
@@ -12085,17 +12106,19 @@ 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);
+     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+     * used to identify and locate the node within the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+     * creating a new node.
+     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     */
+    constructor(key, value, count = 1, color = "BLACK") {
+      super(key, value, color);
       __publicField(this, "_count", 1);
       this.count = count;
     }
@@ -12139,24 +12162,39 @@ var dataStructureTyped = (() => {
     get count() {
       return this._count;
     }
-    getMutableCount() {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
       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.
+     * The function creates a new TreeMultiMapNode with the specified key, value, color, 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.
+     * which is a generic type representing the key type of the node.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+     * function. If provided, it should be of type `V`.
+     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+     * the tree. It is an optional parameter and is used to keep track of the number of values associated
+     * with a key in the tree.
+     * @returns A new instance of the TreeMultiMapNode class is being returned.
      */
-    createNode(key, value, count) {
-      return new TreeMultiMapNode(key, value, count);
+    createNode(key, value, color = "BLACK", count) {
+      return new TreeMultiMapNode(key, value, count, color);
     }
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
@@ -12193,10 +12231,10 @@ var dataStructureTyped = (() => {
         if (key === void 0 || key === null) {
           return;
         } else {
-          node = this.createNode(key, value2, count);
+          node = this.createNode(key, value2, "BLACK", count);
         }
       } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, count);
+        node = this.createNode(keyOrNodeOrEntry, value, "BLACK", count);
       } else {
         return;
       }
@@ -12338,7 +12376,7 @@ var dataStructureTyped = (() => {
         }
       }
       this._size--;
-      if (originalColor === 0 /* BLACK */) {
+      if (originalColor === "BLACK") {
         this._deleteFixup(replacementNode);
       }
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
@@ -12375,7 +12413,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
       if (sorted.length < 1)
         return false;
       this.clear();
@@ -12441,7 +12479,7 @@ var dataStructureTyped = (() => {
       destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
         const { key, value, count, color } = destNode;
-        const tempNode = this.createNode(key, value, count);
+        const tempNode = this.createNode(key, value, color, count);
         if (tempNode) {
           tempNode.color = color;
           destNode.key = srcNode.key;