deque-typed 1.48.2 → 1.48.4

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

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BSTNodeKeyOrNode, BTNKey, BTNodeExemplar } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BSTNodeKeyOrNode, BTNodeExemplar } from '../../types';
 import { BTNCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
+export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     height: number;
-    constructor(key: BTNKey, value?: V);
+    constructor(key: K, value?: V);
 }
 /**
  * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
@@ -23,27 +23,27 @@ export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeN
  * 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<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>, TREE extends AVLTree<V, N, TREE> = AVLTree<V, N, AVLTreeNested<V, N>>> extends BST<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+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<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<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<V, N>>, options?: Partial<AVLTreeOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<AVLTreeOptions<K>>);
     /**
      * The function creates a new AVL tree node with the specified key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
      * type `V`, which means it can be any value that is assignable to the `value` property of the
      * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
-    createNode(key: BTNKey, value?: V): N;
+    createNode(key: K, value?: V): N;
     /**
      * The function creates a new AVL tree with the specified options and returns it.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -51,13 +51,13 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * being created.
      * @returns a new AVLTree object.
      */
-    createTree(options?: AVLTreeOptions): TREE;
+    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<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
      * 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.
@@ -72,7 +72,7 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * entry.
      * @returns The method is returning either the inserted node or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>): 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.
@@ -96,14 +96,14 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N  | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node that
+     * needs to be swapped with the destination node. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N  | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @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<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<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

@@ -29,7 +29,7 @@ exports.AVLTreeNode = AVLTreeNode;
 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<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<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
@@ -43,7 +43,7 @@ class AVLTree extends bst_1.BST {
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
      * type `V`, which means it can be any value that is assignable to the `value` property of the
@@ -61,11 +61,11 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
     isNode(exemplar) {
@@ -126,9 +126,9 @@ class AVLTree extends bst_1.BST {
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N  | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node that
+     * needs to be swapped with the destination node. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N  | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey, BTNodeEntry, BTNodeExemplar, BTNodeKeyOrNode } from '../../types';
+import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNodeEntry, BTNodeExemplar, BTNodeKeyOrNode } from '../../types';
 import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType, NodeDisplayLayout, PairCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterablePairBase } from "../base";
@@ -14,11 +14,11 @@ import { IterablePairBase } from "../base";
  * @template V - The type of data stored in the node.
  * @template N - The type of the family relationship in the binary tree.
  */
-export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> {
-    key: BTNKey;
+export declare class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+    key: K;
     value?: V;
     parent?: N;
-    constructor(key: BTNKey, value?: V);
+    constructor(key: K, value?: V);
     protected _left?: N | null;
     get left(): N | null | undefined;
     set left(v: N | null | undefined);
@@ -42,7 +42,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * 8. Full Trees: Every node has either 0 or 2 children.
  * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
-export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>, TREE extends BinaryTree<V, N, TREE> = BinaryTree<V, N, BinaryTreeNested<V, N>>> extends IterablePairBase<BTNKey, V | undefined> implements IBinaryTree<V, N, TREE> {
+export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterablePairBase<K, V | undefined> implements IBinaryTree<K, V, N, TREE> {
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
@@ -53,18 +53,20 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BinaryTreeOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>);
+    protected _extractor: (key: K) => number;
+    get extractor(): (key: K) => number;
     protected _root?: N | null;
     get root(): N | null | undefined;
     protected _size: number;
     get size(): number;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BTNKey} key - The key for the new node.
+     * @param {K} key - The key for the new node.
      * @param {V} value - The value for the new node.
      * @returns {N} - The newly created BinaryTreeNode.
      */
-    createNode(key: BTNKey, value?: V): N;
+    createNode(key: K, value?: V): N;
     /**
      * The function creates a binary tree with the given options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -72,28 +74,28 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
      * @returns a new instance of a binary tree.
      */
-    createTree(options?: Partial<BinaryTreeOptions>): TREE;
+    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<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V,N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the class N.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
      * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
      * object.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * @param exemplar - BTNodeExemplar<K, V,N> - A generic type representing the exemplar parameter of the
      * function. It can be any type.
      * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | null | undefined;
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>): N | null | undefined;
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
+     * @param kne - BTNodeExemplar<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<V, N>): kne is BTNodeEntry<V>;
+    isEntry(kne: BTNodeExemplar<K, V, N>): kne is BTNodeEntry<K, V>;
     /**
      * Time Complexity O(log n) - O(n)
      * Space Complexity O(1)
@@ -106,7 +108,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be one of the following:
      * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | null | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>): N | null | undefined;
     /**
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
@@ -119,11 +121,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
      * current instance, and returns an array of the inserted nodes.
      * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-     * `BTNodeExemplar<V, N>` objects.
+     * `BTNodeExemplar<K, V,N>` objects.
      * @returns The function `addMany` returns an array of values, where each value is either of type
      * `N`, `null`, or `undefined`.
      */
-    addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (N | null | undefined)[];
+    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (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)
@@ -136,12 +138,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
      * contain either `BTNodeExemplar` objects, keys, or entries.
      */
-    refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<V, N>>): void;
+    refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>): 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, BTNKey>>(identifier: BTNKey, callback?: C): BiTreeDeleteResult<N>[];
+    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>[];
     /**
@@ -153,15 +155,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node in a binary tree.
-     * @param {BTNKey | N | null | undefined} distNode - The `distNode` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `BTNKey`, `N`, `null`, or
+     * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+     * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
      * `undefined`.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `BTNKey` (binary tree node key) or
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
      * `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<N>, beginRoot?: BTNodeKeyOrNode<N>): number;
+    getDepth(distNode: BTNodeKeyOrNode<K, N>, beginRoot?: BTNodeKeyOrNode<K, N>): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -172,15 +174,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
      * iterative traversal.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `BTNKey`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
+     * `K`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
      * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
      * height of the tree using a recursive approach or an iterative approach. It can have two possible
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): number;
+    getHeight(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -192,14 +194,14 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `BTNKey`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
+     * type `K`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
      * 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<N>, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -211,33 +213,33 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `BTNKey` (a key
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
      * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
      * @returns a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: BTNodeKeyOrNode<N>): boolean;
+    isPerfectlyBalanced(beginRoot?: BTNodeKeyOrNode<K, N>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      */
-    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): 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[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
      */
-    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
+    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;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
      */
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
+    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;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -248,7 +250,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
      * recursive or iterative iteration.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to find the node with the matching key value.
      * @param iterationType - The `iterationType` parameter is used to determine whether the search for
      * the node with the given key should be performed iteratively or recursively. It has two possible
@@ -256,7 +258,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -264,7 +266,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
-     * @param {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
@@ -272,10 +274,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @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<N>, iterationType?: IterationType): N | null | undefined;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): V | undefined;
+    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;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -295,15 +297,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which you want to find the path to the root. It can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
      * 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<N>, isReverse?: boolean): N[];
+    getPathToRoot(beginRoot: BTNodeKeyOrNode<K, N>, isReverse?: boolean): N[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -314,15 +316,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for finding the leftmost node in a binary tree. It can be either a `BTNKey` (a key value), `N` (a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `N` (a
      * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the leftmost node in a binary tree. It can have two possible values:
      * @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<N>, iterationType?: IterationType): N | null | undefined;
+    getLeftMost(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -333,8 +335,8 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      *
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which we want to find the rightmost node. It can be of type `K`, `N`,
      * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
      * current object.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
@@ -342,7 +344,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @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<N>, iterationType?: IterationType): N | null | undefined;
+    getRightMost(beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -352,14 +354,14 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Space Complexity: O(1)
      *
      * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
      * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
+    isSubtreeBST(beginRoot: BTNodeKeyOrNode<K, N>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -380,9 +382,9 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    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>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -407,29 +409,29 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      */
     isNodeOrNull(node: any): node is N | null;
     /**
-     * The function "isNodeKey" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a number.
      * @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.
      */
-    isNodeKey(potentialKey: any): potentialKey is number;
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    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>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    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>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    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>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -437,11 +439,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     getPredecessor(node: N): N;
     /**
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
-     * @param {BTNKey | N | null} [x] - The parameter `x` can be of type `BTNKey`, `N`, or `null`.
+     * @param {K | N | null} [x] - The parameter `x` can be of type `K`, `N`, or `null`.
      * @returns the successor of the given node or key. The successor is the node that comes immediately
      * after the given node in the inorder traversal of the binary tree.
      */
-    getSuccessor(x?: BTNKey | N | null): N | null | undefined;
+    getSuccessor(x?: K | N | null): N | null | undefined;
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -453,14 +455,14 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
      * `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<N>): ReturnType<C>[];
+    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<K, N>): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -493,7 +495,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The `filter` method is returning a new tree object that contains the key-value pairs that
      * pass the given predicate function.
      */
-    filter(predicate: PairCallback<BTNKey, V | undefined, boolean>, thisArg?: any): TREE;
+    filter(predicate: PairCallback<K, V | undefined, boolean>, thisArg?: any): TREE;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -513,25 +515,25 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * will be used as the `this` value when the callback function is called. If you don't pass a value
      * @returns The `map` method is returning a new tree object.
      */
-    map(callback: PairCallback<BTNKey, V | undefined, V>, thisArg?: any): TREE;
+    map(callback: PairCallback<K, V | undefined, V>, thisArg?: any): TREE;
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {BTNKey | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `BTNKey | N | null |
+     * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * 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<N>, options?: BinaryTreePrintOptions): void;
-    protected _getIterator(node?: N | null | undefined): IterableIterator<[BTNKey, V | undefined]>;
+    print(beginRoot?: BTNodeKeyOrNode<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) => number;
+    protected _defaultOneParamCallback: (node: N) => K;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.
      * @param {N} destNode - The destination node to swap.
      * @returns {N} - The destination node after the swap.
      */
-    protected _swapProperties(srcNode: BTNodeKeyOrNode<N>, destNode: BTNodeKeyOrNode<N>): N | undefined;
+    protected _swapProperties(srcNode: BTNodeKeyOrNode<K, N>, destNode: BTNodeKeyOrNode<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
@@ -552,7 +554,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * 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<N>): N | null | undefined;
+    protected _addTo(newNode: N | null | undefined, parent: BTNodeKeyOrNode<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.