priority-queue-typed 1.48.9 → 1.49.1

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
+import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNExemplar, BTNKeyOrNode } from '../../types';
 import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -46,12 +46,12 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
     protected _root?: N;
     get root(): N | undefined;
     protected _variant: BSTVariant;
@@ -75,19 +75,19 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
     createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node.
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -104,7 +104,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
      * node was not added.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
@@ -129,7 +129,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * `this.iterationType`, which suggests that it is a property of the current object.
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
      * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(n) - Additional space is required for the sorted array.
@@ -149,7 +149,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot?: BSTNodeKeyOrNode<K, N>): K | undefined;
+    lastKey(beginRoot?: BSTNKeyOrNode<K, N>): K | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -169,6 +169,13 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -182,7 +189,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNode(key: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | undefined;
+    ensureNode(key: BSTNKeyOrNode<K, N>, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -206,7 +213,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNKeyOrNode<K, N>, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -232,7 +239,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

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

@@ -58,7 +58,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
@@ -105,7 +105,7 @@ class BST extends binary_tree_1.BinaryTree {
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -114,7 +114,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node.
      * @returns a node of type N or undefined.
@@ -387,6 +387,15 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof BSTNode);
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BinaryTreeDeleteResult, BTNCallback, BTNExemplar, BTNKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
@@ -24,7 +24,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -32,7 +32,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
     protected _root: N;
     get root(): N;
     protected _size: number;
@@ -60,20 +60,27 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     createTree(options?: RBTreeOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -90,7 +97,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * being added to the binary search tree.
      * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -108,9 +115,9 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -120,24 +127,11 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     getNode<C extends BTNCallback<N, N>>(identifier: N | undefined, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x: N): N | undefined;
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.

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

@@ -10,7 +10,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
 const types_1 = require("../../types");
 const bst_1 = require("./bst");
-const binary_tree_1 = require("./binary-tree");
 class RedBlackTreeNode extends bst_1.BSTNode {
     constructor(key, value, color = types_1.RBTNColor.BLACK) {
         super(key, value);
@@ -29,7 +28,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -78,16 +77,25 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
     isNode(exemplar) {
         return exemplar instanceof RedBlackTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof RedBlackTreeNode);
+    }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
@@ -198,7 +206,7 @@ class RedBlackTree extends bst_1.BST {
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         const ans = [];
@@ -263,7 +271,9 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      */
     isRealNode(node) {
-        return node !== this.Sentinel && node !== undefined;
+        if (node === this.Sentinel || node === undefined)
+            return false;
+        return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -292,41 +302,17 @@ class RedBlackTree extends bst_1.BST {
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        if (identifier instanceof binary_tree_1.BinaryTreeNode)
+        if (identifier instanceof RedBlackTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNode(beginRoot);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x) {
-        var _a;
-        if (x.right !== this.Sentinel) {
-            return (_a = this.getLeftMost(x.right)) !== null && _a !== void 0 ? _a : undefined;
-        }
-        let y = x.parent;
-        while (y !== this.Sentinel && y !== undefined && x === y.right) {
-            x = y;
-            y = y.parent;
-        }
-        return y;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.
@@ -335,11 +321,11 @@ class RedBlackTree extends bst_1.BST {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.Sentinel) {
+        if (this.isRealNode(x.left)) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.Sentinel && x === y.left) {
+        while (this.isRealNode(y) && x === y.left) {
             x = y;
             y = y.parent;
         }

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNExemplar, BTNKeyOrNode, TreeMultimapNested, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
@@ -27,7 +27,7 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
     private _count;
     get count(): number;
     /**
@@ -43,14 +43,21 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
     createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -59,7 +66,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -80,7 +87,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method is returning either the newly inserted node or `undefined` if the insertion
      * was not successful.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -95,7 +102,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * either keys, nodes, or entries.
      * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>): (N | undefined)[];
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -133,9 +140,9 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
      * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
@@ -171,7 +178,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
-    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BSTNKeyOrNode<K, N>): N | undefined;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
@@ -181,6 +188,6 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined;
     protected _replaceNode(oldNode: N, newNode: N): N;
 }

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

@@ -53,16 +53,25 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
     isNode(exemplar) {
         return exemplar instanceof TreeMultimapNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -216,7 +225,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
         var _a;

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -1,7 +1,13 @@
-import type { DijkstraResult, VertexKey } from '../../types';
-import { EntryCallback } from "../../types";
-import { IGraph } from '../../interfaces';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
 import { IterableEntryBase } from "../base";
+import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
     key: VertexKey;
     value: V | undefined;

package/dist/data-structures/graph/abstract-graph.js

@@ -1,17 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 const utils_1 = require("../../utils");
-const priority_queue_1 = require("../priority-queue");
-const queue_1 = require("../queue");
 const base_1 = require("../base");
+const heap_1 = require("../heap");
+const queue_1 = require("../queue");
 class AbstractVertex {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -440,13 +433,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
-        if (getMinDist === undefined)
-            getMinDist = false;
-        if (genPaths === undefined)
-            genPaths = false;
-        if (dest === undefined)
-            dest = undefined;
+    dijkstraWithoutHeap(src, dest = undefined, getMinDist = false, genPaths = false) {
         let minDist = Infinity;
         let minDest = undefined;
         let minPath = [];
@@ -575,14 +562,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src, dest, getMinDist, genPaths) {
+    dijkstra(src, dest = undefined, getMinDist = false, genPaths = false) {
         var _a;
-        if (getMinDist === undefined)
-            getMinDist = false;
-        if (genPaths === undefined)
-            genPaths = false;
-        if (dest === undefined)
-            dest = undefined;
         let minDist = Infinity;
         let minDest = undefined;
         let minPath = [];
@@ -600,7 +581,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new priority_queue_1.PriorityQueue([], { comparator: (a, b) => a.key - b.key });
+        const heap = new heap_1.Heap([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, undefined);
@@ -969,13 +950,28 @@ class AbstractGraph extends base_1.IterableEntryBase {
         }
         const cycles = new Map();
         if (needCycles) {
-            let SCCs = new Map();
-            if (SCCs.size < 1) {
-                SCCs = getSCCs();
-            }
-            SCCs.forEach((SCC, low) => {
-                if (SCC.length > 1) {
-                    cycles.set(low, SCC);
+            const visitedMap = new Map();
+            const stack = [];
+            const findCyclesDFS = (cur, parent) => {
+                visitedMap.set(cur, true);
+                stack.push(cur);
+                const neighbors = this.getNeighbors(cur);
+                for (const neighbor of neighbors) {
+                    if (!visitedMap.get(neighbor)) {
+                        findCyclesDFS(neighbor, cur);
+                    }
+                    else if (stack.includes(neighbor) && neighbor !== parent) {
+                        const cycleStartIndex = stack.indexOf(neighbor);
+                        const cycle = stack.slice(cycleStartIndex);
+                        const cycleLow = Math.min(...cycle.map(v => dfnMap.get(v) || Infinity));
+                        cycles.set(cycleLow, cycle);
+                    }
+                }
+                stack.pop();
+            };
+            vertexMap.forEach(v => {
+                if (!visitedMap.get(v)) {
+                    findCyclesDFS(v, undefined);
                 }
             });
         }