min-heap-typed 1.49.0 → 1.49.1

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

@@ -6,8 +6,7 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BSTNodeKeyOrNode, BTNodeExemplar } from '../../types';
-import { BTNCallback, BTNodeKeyOrNode } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNExemplar, BTNKeyOrNode } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     height: number;
@@ -21,19 +20,18 @@ export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
- * 8. Memory Overhead: Stores balance factors (or heights) at each node, leading to slightly higher memory usage compared to a regular BST.
  */
 export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>> extends BST<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     /**
      * The constructor function initializes an AVLTree object 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 a collection of elements that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
      * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<AVLTreeOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<AVLTreeOptions<K>>);
     /**
      * The function creates a new AVL tree node with the specified key and value.
      * @param {K} key - The key parameter is the key value that will be associated with
@@ -54,17 +52,17 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
     createTree(options?: AVLTreeOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @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 AVLTreeNode 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: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -81,7 +79,7 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      * being added to the binary tree.
      * @returns The method is returning either the inserted node 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) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -99,9 +97,9 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
      * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
      * parameter of type `N
-     * @returns The method is returning an array of `BiTreeDeleteResult<N>`.
+     * @returns The method is returning an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C): BinaryTreeDeleteResult<N>[];
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
@@ -112,7 +110,7 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      * @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;
     /**
      * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.

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

@@ -24,12 +24,11 @@ exports.AVLTreeNode = AVLTreeNode;
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
- * 8. Memory Overhead: Stores balance factors (or heights) at each node, leading to slightly higher memory usage compared to a regular BST.
  */
 class AVLTree extends bst_1.BST {
     /**
      * The constructor function initializes an AVLTree object 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 a collection of elements that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -65,7 +64,7 @@ class AVLTree extends bst_1.BST {
     }
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @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 AVLTreeNode class.
      */
     isNode(exemplar) {
@@ -121,7 +120,7 @@ class AVLTree extends bst_1.BST {
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
      * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
      * parameter of type `N
-     * @returns The method is returning an array of `BiTreeDeleteResult<N>`.
+     * @returns The method is returning an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         if (identifier instanceof AVLTreeNode)

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNodeEntry, BTNodeExemplar, BTNodeKeyOrNode } from '../../types';
-import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeDisplayLayout } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, BTNExemplar, BTNKeyOrNode, DFSOrderPattern, EntryCallback, NodeDisplayLayout } from '../../types';
+import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from "../base";
 /**
@@ -42,14 +42,14 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
+     * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
      * elements to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>);
     protected _extractor: (key: K) => number;
     get extractor(): (key: K) => number;
     protected _root?: N | null;
@@ -73,26 +73,26 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
     /**
      * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @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 class N.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @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 no value
      * is provided, it will be `undefined`.
      * @returns a value of type N (node), or null, or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | null | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | null | undefined;
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNodeExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+     * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isEntry(kne: BTNodeExemplar<K, V, N>): kne is BTNodeEntry<K, V>;
+    isEntry(kne: BTNExemplar<K, V, N>): kne is BTNEntry<K, V>;
     /**
      * Time Complexity O(log n) - O(n)
      * Space Complexity O(1)
@@ -107,7 +107,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @param {V} [value] - The value to be inserted into the binary tree.
      * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | null | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | null | undefined;
     /**
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
@@ -119,23 +119,23 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * The `addMany` function takes in a collection of nodes and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
-     * @param nodes - An iterable collection of BTNodeExemplar objects.
+     * @param nodes - An iterable collection of BTNExemplar objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+    addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
      */
-    refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): void;
+    refill(nodesOrKeysOrEntries: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): void;
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
      */
-    delete<C extends BTNCallback<N, K>>(identifier: K, callback?: C): BiTreeDeleteResult<N>[];
-    delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N, K>>(identifier: K, callback?: C): BinaryTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -153,7 +153,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
-    getDepth(distNode: BTNodeKeyOrNode<K, N>, beginRoot?: BTNodeKeyOrNode<K, N>): number;
+    getDepth(distNode: BTNKeyOrNode<K, N>, beginRoot?: BTNKeyOrNode<K, N>): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -172,7 +172,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): number;
+    getHeight(beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -191,7 +191,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -208,28 +208,28 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
      * @returns a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: BTNodeKeyOrNode<K, N>): boolean;
+    isPerfectlyBalanced(beginRoot?: BTNKeyOrNode<K, N>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      */
-    getNodes<C extends BTNCallback<N, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
      */
-    has<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
      */
-    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -264,10 +264,10 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNode(key: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
-    get<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): V | undefined;
+    ensureNode(key: BTNKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
+    get<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): V | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -295,7 +295,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
-    getPathToRoot(beginRoot: BTNodeKeyOrNode<K, N>, isReverse?: boolean): N[];
+    getPathToRoot(beginRoot: BTNKeyOrNode<K, N>, isReverse?: boolean): N[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -314,7 +314,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
+    getLeftMost(beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -334,7 +334,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
+    getRightMost(beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -351,7 +351,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): boolean;
+    isSubtreeBST(beginRoot: BTNKeyOrNode<K, N>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -372,9 +372,9 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -385,43 +385,43 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isRealNode(node: BTNodeExemplar<K, V, N>): node is N;
+    isRealNode(node: BTNExemplar<K, V, N>): node is N;
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isNIL(node: BTNodeExemplar<K, V, N>): boolean;
+    isNIL(node: BTNExemplar<K, V, N>): boolean;
     /**
      * The function checks if a given node is a real node or null.
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: BTNodeExemplar<K, V, N>): node is N | null;
+    isNodeOrNull(node: BTNExemplar<K, V, N>): node is N | null;
     /**
      * 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: BTNodeKeyOrNode<K, N>): potentialKey is K;
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -461,7 +461,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * `callback` function on each node in the binary tree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<K, N>): ReturnType<C>[];
+    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNode<K, N>): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -522,7 +522,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * following types:
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
      */
-    print(beginRoot?: BTNodeKeyOrNode<K, N>, options?: BinaryTreePrintOptions): void;
+    print(beginRoot?: BTNKeyOrNode<K, N>, options?: BinaryTreePrintOptions): void;
     protected _getIterator(node?: N | null | undefined): IterableIterator<[K, V | undefined]>;
     protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _defaultOneParamCallback: (node: N) => K;
@@ -532,7 +532,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @param {N} destNode - The destination node to swap.
      * @returns {N} - The destination node after the swap.
      */
-    protected _swapProperties(srcNode: BTNodeKeyOrNode<K, N>, destNode: BTNodeKeyOrNode<K, N>): N | undefined;
+    protected _swapProperties(srcNode: BTNKeyOrNode<K, N>, destNode: BTNKeyOrNode<K, N>): N | undefined;
     /**
      * The function replaces an old node with a new node in a binary tree.
      * @param {N} oldNode - The oldNode parameter represents the node that needs to be replaced in the
@@ -553,7 +553,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * the binary tree. If neither the left nor right child is available, the function returns undefined.
      * If the parent node is null, the function also returns undefined.
      */
-    protected _addTo(newNode: N | null | undefined, parent: BTNodeKeyOrNode<K, N>): N | null | undefined;
+    protected _addTo(newNode: N | null | undefined, parent: BTNKeyOrNode<K, N>): N | null | undefined;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.

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

@@ -69,7 +69,7 @@ exports.BinaryTreeNode = BinaryTreeNode;
 class BinaryTree extends base_1.IterableEntryBase {
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
+     * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
      * elements to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
@@ -124,7 +124,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @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 class N.
      */
     isNode(exemplar) {
@@ -132,7 +132,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @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 no value
      * is provided, it will be `undefined`.
@@ -170,7 +170,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNodeExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+     * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
@@ -248,7 +248,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `addMany` function takes in a collection of nodes and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
-     * @param nodes - An iterable collection of BTNodeExemplar objects.
+     * @param nodes - An iterable collection of BTNExemplar objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
@@ -292,7 +292,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @param {C} callback - The `callback` parameter is a function that is used to determine the
      * identifier of the node to be deleted. It is optional and has a default value of
      * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         const deletedResult = [];

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
-import { BSTVariant, BTNodeKeyOrNode, CP, IterationType } 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';
 export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
@@ -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.
@@ -175,7 +175,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    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.
@@ -189,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.
@@ -213,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.
@@ -239,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.