data-structure-typed 1.52.8 → 1.52.9

package/dist/mjs/data-structures/binary-tree/tree-multi-map.js

@@ -179,25 +179,26 @@ export class TreeMultiMap extends RedBlackTree {
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
-     * function.
+     * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
      * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
      */
-    delete(predicate, ignoreCount = false) {
-        if (predicate === null)
+    delete(keyOrNodeOrEntryOrRaw, ignoreCount = false) {
+        if (keyOrNodeOrEntryOrRaw === null)
             return [];
         const results = [];
         let nodeToDelete;
-        if (this._isPredicated(predicate))
-            nodeToDelete = this.getNode(predicate);
+        if (this._isPredicated(keyOrNodeOrEntryOrRaw))
+            nodeToDelete = this.getNode(keyOrNodeOrEntryOrRaw);
         else
-            nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+            nodeToDelete = this.isRealNode(keyOrNodeOrEntryOrRaw)
+                ? keyOrNodeOrEntryOrRaw
+                : this.getNode(keyOrNodeOrEntryOrRaw);
         if (!nodeToDelete) {
             return results;
         }

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

@@ -7280,19 +7280,19 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
      * the deleted node along with information for tree balancing.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw
      * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
-     * node, entry, raw data, or a custom predicate. The method returns an array of
+     * node, entry or raw data. The method returns an array of
      * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
      * balancing is needed.
      * @returns The `delete` method returns an array of `BinaryTreeDeleteResult` objects. Each object in
      * the array contains information about the node that was deleted (`deleted`) and the node that may
      * need to be balanced (`needBalanced`).
      */
-    delete(keyOrNodeOrEntryOrRawOrPredicate) {
+    delete(keyOrNodeOrEntryOrRaw) {
       const deletedResult = [];
       if (!this._root) return deletedResult;
-      const curr = this.getNode(keyOrNodeOrEntryOrRawOrPredicate);
+      const curr = this.getNode(keyOrNodeOrEntryOrRaw);
       if (!curr) return deletedResult;
       const parent = curr == null ? void 0 : curr.parent;
       let needBalanced;
@@ -8251,19 +8251,16 @@ var dataStructureTyped = (() => {
      * binary tree with the specified options.
      */
     toVisual(beginRoot = this._root, options) {
-      const opts = __spreadValues({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
+      const opts = __spreadValues({ isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false }, options);
       beginRoot = this.ensureNode(beginRoot);
       let output = "";
       if (!beginRoot) return output;
-      if (opts.isShowUndefined)
-        output += `U for undefined
-      `;
-      if (opts.isShowNull)
-        output += `N for null
-      `;
-      if (opts.isShowRedBlackNIL)
-        output += `S for Sentinel Node(NIL)
-      `;
+      if (opts.isShowUndefined) output += `U for undefined
+`;
+      if (opts.isShowNull) output += `N for null
+`;
+      if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)
+`;
       const display = (root) => {
         const [lines, , ,] = this._displayAux(root, opts);
         let paragraph = "";
@@ -8275,6 +8272,24 @@ var dataStructureTyped = (() => {
       display(beginRoot);
       return output;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `print` in TypeScript overrides the default print behavior to log a visual
+     * representation of the binary tree to the console.
+     * @param {BinaryTreePrintOptions} [options] - The `options` parameter is used to specify the
+     * printing options for the binary tree. It is an optional parameter that allows you to customize how
+     * the binary tree is printed, such as choosing between different traversal orders or formatting
+     * options.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * `override print` method is used to specify the starting point for printing the binary tree. It can
+     * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
+     * provided, the default value is set to
+     */
+    print(options, beginRoot = this._root) {
+      console.log(this.toVisual(beginRoot, options));
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8846,21 +8861,18 @@ var dataStructureTyped = (() => {
       if (!isBalanceAdd) {
         for (const kve of keysOrNodesOrEntriesOrRaws) {
           const value = valuesIterator == null ? void 0 : valuesIterator.next().value;
-          const nn = this.add(kve, value);
-          inserted.push(nn);
+          inserted.push(this.add(kve, value));
         }
         return inserted;
       }
       const realBTNExemplars = [];
-      const isRealBTNExemplar = (kve) => {
-        if (kve === void 0 || kve === null) return false;
-        return !(this.isEntry(kve) && (kve[0] === void 0 || kve[0] === null));
-      };
+      let i = 0;
       for (const kve of keysOrNodesOrEntriesOrRaws) {
-        if (isRealBTNExemplar(kve)) realBTNExemplars.push(kve);
+        realBTNExemplars.push({ key: kve, value: valuesIterator == null ? void 0 : valuesIterator.next().value, orgIndex: i });
+        i++;
       }
       let sorted = [];
-      sorted = realBTNExemplars.sort((a, b) => {
+      sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
         let keyA, keyB;
         if (this.isEntry(a)) keyA = a[0];
         else if (this.isRealNode(a)) keyA = a.key;
@@ -8884,8 +8896,8 @@ var dataStructureTyped = (() => {
       const _dfs = (arr) => {
         if (arr.length === 0) return;
         const mid = Math.floor((arr.length - 1) / 2);
-        const newNode = this.add(arr[mid]);
-        inserted.push(newNode);
+        const { key, value, orgIndex } = arr[mid];
+        inserted[orgIndex] = this.add(key, value);
         _dfs(arr.slice(0, mid));
         _dfs(arr.slice(mid + 1));
       };
@@ -8898,8 +8910,8 @@ var dataStructureTyped = (() => {
             const [l, r] = popped;
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
-              const newNode = this.add(sorted[m]);
-              inserted.push(newNode);
+              const { key, value, orgIndex } = sorted[m];
+              inserted[orgIndex] = this.add(key, value);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -9917,15 +9929,15 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
      * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete(predicate) {
-      const deletedResults = super.delete(predicate);
+    delete(keyOrNodeOrEntryOrRaw) {
+      const deletedResults = super.delete(keyOrNodeOrEntryOrRaw);
       for (const { needBalanced } of deletedResults) {
         if (needBalanced) {
           this._balancePath(needBalanced);
@@ -10394,7 +10406,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
@@ -10402,12 +10414,13 @@ var dataStructureTyped = (() => {
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(predicate) {
-      if (predicate === null) return [];
+    delete(keyOrNodeOrEntryOrRaw) {
+      if (keyOrNodeOrEntryOrRaw === null) return [];
       const results = [];
       let nodeToDelete;
-      if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
-      else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+      if (this._isPredicated(keyOrNodeOrEntryOrRaw)) nodeToDelete = this.getNode(keyOrNodeOrEntryOrRaw);
+      else
+        nodeToDelete = this.isRealNode(keyOrNodeOrEntryOrRaw) ? keyOrNodeOrEntryOrRaw : this.getNode(keyOrNodeOrEntryOrRaw);
       if (!nodeToDelete) {
         return results;
       }
@@ -10886,9 +10899,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a binary tree data structure, handling deletion of
      * nodes and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition for deleting a node from the
-     * binary tree. It can be a key, node, entry, or a custom predicate function that determines which
+     * binary tree. It can be a key, node, or entry that determines which
      * node(s) should be deleted.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of the node being deleted. If
@@ -10899,11 +10912,11 @@ var dataStructureTyped = (() => {
      * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
      * deleted node and whether balancing is needed in the tree.
      */
-    delete(predicate, ignoreCount = false) {
+    delete(keyOrNodeOrEntryOrRaw, ignoreCount = false) {
       var _a;
       const deletedResult = [];
       if (!this.root) return deletedResult;
-      const curr = (_a = this.getNode(predicate)) != null ? _a : void 0;
+      const curr = (_a = this.getNode(keyOrNodeOrEntryOrRaw)) != null ? _a : void 0;
       if (!curr) return deletedResult;
       const parent = (curr == null ? void 0 : curr.parent) ? curr.parent : void 0;
       let needBalanced = void 0, orgCurrent = curr;
@@ -11238,22 +11251,22 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
-     * function.
+     * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
      * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
      */
-    delete(predicate, ignoreCount = false) {
-      if (predicate === null) return [];
+    delete(keyOrNodeOrEntryOrRaw, ignoreCount = false) {
+      if (keyOrNodeOrEntryOrRaw === null) return [];
       const results = [];
       let nodeToDelete;
-      if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
-      else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+      if (this._isPredicated(keyOrNodeOrEntryOrRaw)) nodeToDelete = this.getNode(keyOrNodeOrEntryOrRaw);
+      else
+        nodeToDelete = this.isRealNode(keyOrNodeOrEntryOrRaw) ? keyOrNodeOrEntryOrRaw : this.getNode(keyOrNodeOrEntryOrRaw);
       if (!nodeToDelete) {
         return results;
       }