priority-queue-typed 1.52.8 → 1.52.9

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, IterationType, BTNEntry } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, IterationType, BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
@@ -127,9 +127,9 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      *
      * 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
@@ -140,7 +140,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
      * deleted node and whether balancing is needed in the tree.
      */
-    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -175,9 +175,9 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      *
      * 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
@@ -188,12 +188,12 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * 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 ? _a : undefined;
+        const curr = (_a = this.getNode(keyOrNodeOrEntryOrRaw)) !== null && _a !== void 0 ? _a : undefined;
         if (!curr)
             return deletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : undefined;

package/dist/data-structures/binary-tree/avl-tree.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, BTNEntry } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
@@ -99,14 +99,14 @@ export declare class AVLTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends
      *
      * 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: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/avl-tree.js

@@ -124,15 +124,15 @@ class AVLTree extends bst_1.BST {
      *
      * 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);

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -235,16 +235,16 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(k + log n)
@@ -657,8 +657,65 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * binary tree with the specified options.
      */
     toVisual(beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, options?: BinaryTreePrintOptions): string;
-    protected _dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
-    protected _dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
+    /**
+     * 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?: BinaryTreePrintOptions, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R): void;
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `_dfs` function performs a depth-first search traversal on a binary tree structure based on
+     * the specified order pattern and callback function.
+     * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
+     * called on each node visited during the depth-first search traversal. It is of type `C`, which
+     * extends `BTNCallback<OptBTNOrNull<NODE>>`. The default value for this parameter is `this._DEFAULT
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
+     * order in which the nodes are visited during the Depth-First Search traversal. It can have one of
+     * the following values:
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `_dfs`
+     * method is used to specify the starting point for the depth-first search traversal in a binary
+     * tree. It can be provided as either a `BTNKeyOrNodeOrEntry` object or a reference to the root node
+     * of the tree. If no specific
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
+     * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
+     * binary tree. It can have two possible values:
+     * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method is a boolean flag
+     * that determines whether null nodes should be included in the depth-first search traversal. If
+     * `includeNull` is set to `true`, null nodes will be considered during the traversal process. If it
+     * is set to `false`,
+     * @param shouldVisitLeft - The `shouldVisitLeft` parameter is a function that takes a node as input
+     * and returns a boolean value. It is used to determine whether the left child of a node should be
+     * visited during the depth-first search traversal. By default, it checks if the node is truthy (not
+     * null or undefined
+     * @param shouldVisitRight - The `shouldVisitRight` parameter is a function that takes a node as an
+     * argument and returns a boolean value. It is used to determine whether the right child of a node
+     * should be visited during the depth-first search traversal. The default implementation checks if
+     * the node is truthy before visiting the right child
+     * @param shouldVisitRoot - The `shouldVisitRoot` parameter is a function that takes a node as an
+     * argument and returns a boolean value. It is used to determine whether the root node should be
+     * visited during the depth-first search traversal based on certain conditions. The default
+     * implementation checks if the node is a real node or null based
+     * @param shouldProcessRoot - The `shouldProcessRoot` parameter is a function that takes a node as an
+     * argument and returns a boolean value indicating whether the node should be processed during the
+     * depth-first search traversal. The default implementation checks if the node is a real node or null
+     * based on the `includeNull` flag. If `
+     * @returns The function `_dfs` returns an array of the return type of the callback function provided
+     * as input.
+     */
+    protected _dfs<C extends BTNCallback<OptBTNOrNull<NODE>>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType, includeNull?: boolean, shouldVisitLeft?: (node: OptBTNOrNull<NODE>) => boolean, shouldVisitRight?: (node: OptBTNOrNull<NODE>) => boolean, shouldVisitRoot?: (node: OptBTNOrNull<NODE>) => boolean, shouldProcessRoot?: (node: OptBTNOrNull<NODE>) => boolean): ReturnType<C>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/binary-tree.js

@@ -430,20 +430,20 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * 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 || curr === void 0 ? void 0 : curr.parent;
@@ -1492,20 +1492,17 @@ class BinaryTree extends base_1.IterableEntryBase {
      * binary tree with the specified options.
      */
     toVisual(beginRoot = this._root, options) {
-        const opts = Object.assign({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
+        const opts = Object.assign({ isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false }, options);
         beginRoot = this.ensureNode(beginRoot);
         let output = '';
         if (!beginRoot)
             return output;
         if (opts.isShowUndefined)
-            output += `U for undefined
-      `;
+            output += `U for undefined\n`;
         if (opts.isShowNull)
-            output += `N for null
-      `;
+            output += `N for null\n`;
         if (opts.isShowRedBlackNIL)
-            output += `S for Sentinel Node(NIL)
-      `;
+            output += `S for Sentinel Node(NIL)\n`;
         const display = (root) => {
             const [lines, , ,] = this._displayAux(root, opts);
             let paragraph = '';
@@ -1517,6 +1514,24 @@ class BinaryTree extends base_1.IterableEntryBase {
         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)

package/dist/data-structures/binary-tree/bst.js

@@ -246,23 +246,18 @@ class BST extends binary_tree_1.BinaryTree {
         if (!isBalanceAdd) {
             for (const kve of keysOrNodesOrEntriesOrRaws) {
                 const value = valuesIterator === null || valuesIterator === void 0 ? 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 === undefined || kve === null)
-                return false;
-            return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
-        };
+        let i = 0;
         for (const kve of keysOrNodesOrEntriesOrRaws) {
-            if (isRealBTNExemplar(kve))
-                realBTNExemplars.push(kve);
+            realBTNExemplars.push({ key: kve, value: valuesIterator === null || valuesIterator === void 0 ? 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];
@@ -293,8 +288,8 @@ class BST extends binary_tree_1.BinaryTree {
             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));
         };
@@ -307,8 +302,8 @@ class BST extends binary_tree_1.BinaryTree {
                     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]);
                     }

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BTNKeyOrNodeOrEntry, BTNPredicate, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested, BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BTNKeyOrNodeOrEntry, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested, BTNEntry } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -107,7 +107,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * 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.
@@ -115,7 +115,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/rb-tree.js

@@ -184,7 +184,7 @@ class RedBlackTree extends bst_1.BST {
      *
      * 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.
@@ -192,15 +192,17 @@ class RedBlackTree extends bst_1.BST {
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(predicate) {
-        if (predicate === null)
+    delete(keyOrNodeOrEntryOrRaw) {
+        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/data-structures/binary-tree/tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions, BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions, BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
@@ -128,17 +128,16 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * 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: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -178,25 +178,26 @@ class TreeMultiMap extends rb_tree_1.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "priority-queue-typed",
-  "version": "1.52.8",
+  "version": "1.52.9",
   "description": "Priority Queue, Min Priority Queue, Max Priority Queue. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -120,6 +120,6 @@
     "typedoc": "^0.25.1"
   },
   "dependencies": {
-    "data-structure-typed": "^1.52.8"
+    "data-structure-typed": "^1.52.9"
   }
 }

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

@@ -12,7 +12,6 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNKeyOrNodeOrEntry,
-  BTNPredicate,
   IterationType,
   BTNEntry
 } from '../../types';
@@ -232,9 +231,9 @@ export class AVLTreeMultiMap<
    *
    * 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
@@ -246,13 +245,13 @@ export class AVLTreeMultiMap<
    * deleted node and whether balancing is needed in the tree.
    */
   override delete(
-    predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>,
+    keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
 
-    const curr: NODE | undefined = this.getNode(predicate) ?? undefined;
+    const curr: NODE | undefined = this.getNode(keyOrNodeOrEntryOrRaw) ?? undefined;
     if (!curr) return deletedResult;
 
     const parent: NODE | undefined = curr?.parent ? curr.parent : undefined;

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

@@ -13,7 +13,6 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNKeyOrNodeOrEntry,
-  BTNPredicate,
   BTNEntry
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -160,15 +159,15 @@ export class AVLTree<
    *
    * 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.
    */
-  override delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[] {
-    const deletedResults = super.delete(predicate);
+  override delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[] {
+    const deletedResults = super.delete(keyOrNodeOrEntryOrRaw);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
         this._balancePath(needBalanced);

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

@@ -515,22 +515,20 @@ export class BinaryTree<
    *
    * 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: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>
-  ): BinaryTreeDeleteResult<NODE>[] {
+  delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this._root) return deletedResult;
 
-    const curr = this.getNode(keyOrNodeOrEntryOrRawOrPredicate);
+    const curr = this.getNode(keyOrNodeOrEntryOrRaw);
     if (!curr) return deletedResult;
 
     const parent: NODE | undefined = curr?.parent;
@@ -1683,20 +1681,14 @@ export class BinaryTree<
     beginRoot: BTNKeyOrNodeOrEntry<K, V, NODE> | R = this._root,
     options?: BinaryTreePrintOptions
   ): string {
-    const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
+    const opts = { 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\n`;
+    if (opts.isShowNull) output += `N for null\n`;
+    if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)\n`;
 
     const display = (root: OptBTNOrNull<NODE>): void => {
       const [lines, , ,] = this._displayAux(root, opts);
@@ -1711,20 +1703,24 @@ export class BinaryTree<
     return output;
   }
 
-  protected _dfs<C extends BTNCallback<NODE>>(
-    callback?: C,
-    pattern?: DFSOrderPattern,
-    beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
-    iterationType?: IterationType
-  ): ReturnType<C>[];
-
-  protected _dfs<C extends BTNCallback<NODE | null>>(
-    callback?: C,
-    pattern?: DFSOrderPattern,
-    beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
-    iterationType?: IterationType,
-    includeNull?: boolean
-  ): ReturnType<C>[];
+  /**
+   * 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
+   */
+  override print(options?: BinaryTreePrintOptions, beginRoot: BTNKeyOrNodeOrEntry<K, V, NODE> | R = this._root) {
+    console.log(this.toVisual(beginRoot, options));
+  }
 
   /**
    * Time complexity: O(n)

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

@@ -14,7 +14,6 @@ import type {
   BTNEntry,
   BTNKeyOrNodeOrEntry,
   BTNPredicate,
-  BTNPureKeyOrNodeOrEntry,
   Comparator,
   CP,
   DFSOrderPattern,
@@ -310,28 +309,26 @@ export class BST<
     if (!isBalanceAdd) {
       for (const kve of keysOrNodesOrEntriesOrRaws) {
         const value = valuesIterator?.next().value;
-        const nn = this.add(kve, value);
-        inserted.push(nn);
+        inserted.push(this.add(kve, value));
       }
       return inserted;
     }
 
-    const realBTNExemplars: (R | BTNPureKeyOrNodeOrEntry<K, V, NODE>)[] = [];
-
-    const isRealBTNExemplar = (
-      kve: BTNKeyOrNodeOrEntry<K, V, NODE> | R
-    ): kve is BTNPureKeyOrNodeOrEntry<K, V, NODE> => {
-      if (kve === undefined || kve === null) return false;
-      return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
-    };
+    const realBTNExemplars: {
+      key: R | BTNKeyOrNodeOrEntry<K, V, NODE>;
+      value: V | undefined;
+      orgIndex: number;
+    }[] = [];
 
+    let i = 0;
     for (const kve of keysOrNodesOrEntriesOrRaws) {
-      if (isRealBTNExemplar(kve)) realBTNExemplars.push(kve);
+      realBTNExemplars.push({ key: kve, value: valuesIterator?.next().value, orgIndex: i });
+      i++;
     }
 
-    let sorted: (R | BTNPureKeyOrNodeOrEntry<K, V, NODE>)[] = [];
+    let sorted: { key: R | BTNKeyOrNodeOrEntry<K, V, NODE>; value: V | undefined; orgIndex: number }[] = [];
 
-    sorted = realBTNExemplars.sort((a, b) => {
+    sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
       let keyA: K | undefined | null, keyB: K | undefined | null;
       if (this.isEntry(a)) keyA = a[0];
       else if (this.isRealNode(a)) keyA = a.key;
@@ -355,12 +352,12 @@ export class BST<
       return 0;
     });
 
-    const _dfs = (arr: (R | BTNPureKeyOrNodeOrEntry<K, V, NODE>)[]) => {
+    const _dfs = (arr: { key: R | BTNKeyOrNodeOrEntry<K, V, NODE>; value: V | undefined; orgIndex: number }[]) => {
       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));
     };
@@ -374,8 +371,8 @@ export class BST<
           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]);
           }

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

@@ -1,7 +1,6 @@
 import type {
   BinaryTreeDeleteResult,
   BTNKeyOrNodeOrEntry,
-  BTNPredicate,
   CRUD,
   OptBSTN,
   RBTNColor,
@@ -230,7 +229,7 @@ export class RedBlackTree<
    *
    * 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.
@@ -238,13 +237,16 @@ export class RedBlackTree<
    * objects. Each object in the array contains information about the deleted node and whether
    * balancing is needed.
    */
-  override delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[] {
-    if (predicate === null) return [];
+  override delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[] {
+    if (keyOrNodeOrEntryOrRaw === null) return [];
 
     const results: BinaryTreeDeleteResult<NODE>[] = [];
     let nodeToDelete: OptBSTN<NODE>;
-    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;

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

@@ -9,7 +9,6 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNKeyOrNodeOrEntry,
-  BTNPredicate,
   IterationType,
   OptBSTN,
   RBTNColor,
@@ -232,10 +231,9 @@ export class TreeMultiMap<
    *
    * 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
@@ -243,16 +241,19 @@ export class TreeMultiMap<
    * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
    */
   override delete(
-    predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>,
+    keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
-    if (predicate === null) return [];
+    if (keyOrNodeOrEntryOrRaw === null) return [];
 
     const results: BinaryTreeDeleteResult<NODE>[] = [];
 
     let nodeToDelete: OptBSTN<NODE>;
-    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;