data-structure-typed 1.34.7 → 1.34.9

package/lib/data-structures/binary-tree/abstract-binary-tree.d.ts

@@ -5,36 +5,27 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AbstractBinaryTreeNodeNested, AbstractBinaryTreeNodeProperties, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../../types';
+import type { AbstractBinaryTreeNodeNested, AbstractBinaryTreeNodeProperties, BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../../types';
 import { AbstractBinaryTreeOptions, FamilyPosition, LoopType } from '../../types';
 import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from '../../interfaces';
 export declare abstract class AbstractBinaryTreeNode<V = any, NEIGHBOR extends AbstractBinaryTreeNode<V, NEIGHBOR> = AbstractBinaryTreeNodeNested<V>> implements IAbstractBinaryTreeNode<V, NEIGHBOR> {
     /**
-     * The constructor function initializes a BinaryTreeNode object with an id and an optional value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+     * The constructor function initializes a BinaryTreeNode object with a key and an optional value.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
      * of the binary tree node. It is used to distinguish one node from another in the binary tree.
      * @param {V} [val] - The "val" parameter is an optional parameter of type V. It represents the value that will be
      * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
-    protected constructor(id: BinaryTreeNodeId, val?: V);
-    private _id;
-    get id(): BinaryTreeNodeId;
-    set id(v: BinaryTreeNodeId);
-    private _val;
-    get val(): V | undefined;
-    set val(value: V | undefined);
+    protected constructor(key: BinaryTreeNodeKey, val?: V);
+    key: BinaryTreeNodeKey;
+    val: V | undefined;
     private _left;
     get left(): NEIGHBOR | null | undefined;
     set left(v: NEIGHBOR | null | undefined);
     private _right;
     get right(): NEIGHBOR | null | undefined;
     set right(v: NEIGHBOR | null | undefined);
-    private _parent;
-    get parent(): NEIGHBOR | null | undefined;
-    set parent(v: NEIGHBOR | null | undefined);
-    private _height;
-    get height(): number;
-    set height(v: number);
+    parent: NEIGHBOR | null | undefined;
     /**
      * The function determines the position of a node in a family tree structure.
      * @returns a value of type `FamilyPosition`.
@@ -54,13 +45,10 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get size(): number;
     private _loopType;
     get loopType(): LoopType;
-    private _visitedId;
-    get visitedId(): BinaryTreeNodeId[];
-    private _visitedVal;
-    get visitedVal(): N['val'][];
-    private _visitedNode;
-    get visitedNode(): N[];
-    abstract createNode(id: BinaryTreeNodeId, val?: N['val']): N | null;
+    visitedKey: BinaryTreeNodeKey[];
+    visitedVal: N['val'][];
+    visitedNode: N[];
+    abstract createNode(key: BinaryTreeNodeKey, val?: N['val']): N | null;
     /**
      * The `swapLocation` function swaps the location of two nodes in a binary tree.
      * @param {N} srcNode - The source node that you want to swap with the destination node.
@@ -70,7 +58,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     swapLocation(srcNode: N, destNode: N): N;
     /**
-     * The clear() function resets the root, size, and maxId properties to their initial values.
+     * The clear() function resets the root, size, and maxKey properties to their initial values.
      */
     clear(): void;
     /**
@@ -84,57 +72,57 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     /**
      * The `add` function adds a new node to a binary tree, either by ID or by creating a new node with a given value.
-     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId`, which
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey`, which
      * is a number representing the ID of a binary tree node, or it can be a `N` object, which represents a binary tree
      * node itself. It can also be `null` if no node is specified.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
      * being added to the binary tree.
      * @returns The function `add` returns either the inserted node (`N`), `null`, or `undefined`.
      */
-    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val']): N | null | undefined;
+    add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
     /**
      * The `addMany` function takes an array of binary tree node IDs or nodes, and optionally an array of corresponding data
      * values, and adds them to the binary tree.
-     * @param {(BinaryTreeNodeId | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeId or BinaryTreeNode
+     * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} keysOrNodes - An array of BinaryTreeNodeKey or BinaryTreeNode
      * objects, or null values.
      * @param {N['val'][]} [data] - The `data` parameter is an optional array of values (`N['val'][]`) that corresponds to
      * the nodes or node IDs being added. It is used to set the value of each node being added. If `data` is not provided,
      * the value of the nodes will be `undefined`.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][]): (N | null | undefined)[];
     /**
-     * The `fill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
-     * @param {(BinaryTreeNodeId | N)[]} idsOrNodes - The `idsOrNodes` parameter is an array that can contain either
-     * `BinaryTreeNodeId` or `N` values.
+     * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
+     * @param {(BinaryTreeNodeKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
+     * `BinaryTreeNodeKey` or `N` values.
      * @param {N[] | Array<N['val']>} [data] - The `data` parameter is an optional array of values that will be assigned to
-     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `idsOrNodes`
+     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `keysOrNodes`
      * array. Each value in the `data` array will be assigned to the
      * @returns The method is returning a boolean value.
      */
-    fill(idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[], data?: N[] | Array<N['val']>): boolean;
+    refill(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N[] | Array<N['val']>): boolean;
     /**
      * The `remove` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
      * containing the deleted node and the node that needs to be balanced.
-     * @param {N | BinaryTreeNodeId} nodeOrId - The `nodeOrId` parameter can be either a node object (`N`) or a binary tree
-     * node ID (`BinaryTreeNodeId`).
+     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object (`N`) or a binary tree
+     * node ID (`BinaryTreeNodeKey`).
      * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrId: N | BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
+    remove(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
      * The function calculates the depth of a node in a binary tree.
-     * @param {N | BinaryTreeNodeId | null} beginRoot - The `beginRoot` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter can be one of the following:
      * @returns the depth of the given node or binary tree.
      */
-    getDepth(beginRoot: N | BinaryTreeNodeId | null): number;
+    getDepth(beginRoot?: N | BinaryTreeNodeKey | null): number;
     /**
      * The `getHeight` function calculates the maximum height of a binary tree, either recursively or iteratively.
-     * @param {N | BinaryTreeNodeId | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
-     * generic type representing a node in a binary tree), `BinaryTreeNodeId` (a type representing the ID of a binary tree
+     * @param {N | BinaryTreeNodeKey | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
+     * generic type representing a node in a binary tree), `BinaryTreeNodeKey` (a type representing the ID of a binary tree
      * node), or `null`.
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: N | BinaryTreeNodeId | null): number;
+    getHeight(beginRoot?: N | BinaryTreeNodeKey | null): number;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
      * approach.
@@ -154,37 +142,37 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     isPerfectlyBalanced(beginRoot?: N | null): boolean;
     /**
      * The function `getNodes` returns an array of nodes that match a given property name and value in a binary tree.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use when searching for nodes. If not provided, it defaults to 'id'.
+     * specifies the property name to use when searching for nodes. If not provided, it defaults to 'key'.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or `propertyName`. If `onlyOne` is set to `true`, the
      * function will stop traversing the tree and return the first matching node. If `only
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
      * The function checks if a binary tree node has a specific property.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or `N`.
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or `N`.
      * It represents the property of the binary tree node that you want to check.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the name of the property to be checked in the nodes. If not provided, it defaults to 'id'.
+     * specifies the name of the property to be checked in the nodes. If not provided, it defaults to 'key'.
      * @returns a boolean value.
      */
-    has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
+    has(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
      * The function returns the first node that matches the given property name and value, or null if no matching node is
      * found.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or `N`.
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or `N`.
      * It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to be used for searching the binary tree nodes. If this parameter is not provided, the
-     * default value is set to `'id'`.
+     * default value is set to `'key'`.
      * @returns either the value of the specified property of the node, or the node itself if no property name is provided.
      * If no matching node is found, it returns null.
      */
-    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     /**
      * The function `getPathToRoot` returns an array of nodes representing the path from a given node to the root node, with
      * an option to reverse the order of the nodes.
@@ -199,7 +187,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     /**
      * The function `getLeftMost` returns the leftmost node in a binary tree, starting from a specified node or the root if
      * no node is specified.
-     * generic type representing a node in a binary tree), `BinaryTreeNodeId` (a type representing the ID of a binary tree
+     * generic type representing a node in a binary tree), `BinaryTreeNodeKey` (a type representing the ID of a binary tree
      * node), or `null`.
      * @returns The function `getLeftMost` returns the leftmost node in a binary tree. If the `beginRoot` parameter is
      * provided, it starts the traversal from that node. If `beginRoot` is not provided or is `null`, it starts the traversal
@@ -210,8 +198,8 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     /**
      * The function `getLeftMost` returns the leftmost node in a binary tree, starting from a specified node or the root if
      * no node is specified.
-     * @param {N | BinaryTreeNodeId | null} [node] - The `beginRoot` parameter is optional and can be of type `N` (a
-     * generic type representing a node in a binary tree), `BinaryTreeNodeId` (a type representing the ID of a binary tree
+     * @param {N | BinaryTreeNodeKey | null} [node] - The `beginRoot` parameter is optional and can be of type `N` (a
+     * generic type representing a node in a binary tree), `BinaryTreeNodeKey` (a type representing the ID of a binary tree
      * node).
      * @returns The function `getLeftMost` returns the leftmost node in a binary tree. If the `beginRoot` parameter is
      * provided, it starts the traversal from that node. If `beginRoot` is not provided or is `null`, it starts the traversal
@@ -229,13 +217,13 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     /**
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or iteratively using tail
      * recursion optimization.
-     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N` or `null`. It represents the
+     * @param {N | null} [beginRoot] - The `node` parameter is an optional parameter of type `N` or `null`. It represents the
      * starting node from which we want to find the rightmost node. If no node is provided, the function will default to
      * using the root node of the data structure.
      * @returns The `getRightMost` function returns the rightmost node in a binary tree. It returns the rightmost node
      * starting from that node.
      */
-    getRightMost(node: N): N;
+    getRightMost(beginRoot: N): N;
     /**
      * The function checks if a binary search tree is valid by traversing it either recursively or iteratively.
      * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
@@ -256,154 +244,176 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     getSubTreeSize(subTreeRoot: N | null | undefined): number;
     /**
      * The function `subTreeSum` calculates the sum of a specified property in a binary tree or subtree.
-     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
+     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
      * tree or the ID of a binary tree node. It can also be `null` if there is no subtree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
-     * property of the binary tree node to use for calculating the sum. It can be either 'id' or 'val'. If propertyName is
-     * not provided, it defaults to 'id'.
+     * property of the binary tree node to use for calculating the sum. It can be either 'key' or 'val'. If propertyName is
+     * not provided, it defaults to 'key'.
      * @returns a number, which is the sum of the values of the specified property in the subtree rooted at `subTreeRoot`.
      */
-    subTreeSum(subTreeRoot: N | BinaryTreeNodeId | null, propertyName?: BinaryTreeNodePropertyName): number;
+    subTreeSum(subTreeRoot: N | BinaryTreeNodeKey | null, propertyName?: BinaryTreeNodePropertyName): number;
     /**
      * The function `subTreeAdd` adds a delta value to a specified property of each node in a subtree.
-     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
+     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
      * tree or the ID of a node in the binary tree. It can also be `null` if there is no subtree to add to.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each node in the subtree should be incremented.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'id'.
+     * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'key'.
      * @returns a boolean value.
      */
-    subTreeAdd(subTreeRoot: N | BinaryTreeNodeId | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    subTreeAdd(subTreeRoot: N | BinaryTreeNodeKey | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
-     * Performs a breadth-first search (BFS) on a binary tree, accumulating properties of each node based on their 'id' property.
+     * Performs a breadth-first search (bfs) on a binary tree, accumulating properties of each node based on their 'key' property.
      * @returns An array of binary tree node IDs.
      */
-    BFS(): BinaryTreeNodeId[];
+    bfs(): BinaryTreeNodeKey[];
     /**
-     * Performs a breadth-first search (BFS) on a binary tree, accumulating properties of each node based on the specified property name.
-     * @param {'id'} nodeOrPropertyName - The name of the property to accumulate.
+     * Performs a breadth-first search (bfs) on a binary tree, accumulating properties of each node based on the specified property name.
+     * @param {'key'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of values corresponding to the specified property.
      */
-    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+    bfs(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
     /**
-     * Performs a breadth-first search (BFS) on a binary tree, accumulating the 'val' property of each node.
+     * Performs a breadth-first search (bfs) on a binary tree, accumulating the 'val' property of each node.
      * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of 'val' properties from each node.
      */
-    BFS(nodeOrPropertyName: 'val'): N['val'][];
+    bfs(nodeOrPropertyName: 'val'): N['val'][];
     /**
-     * Performs a breadth-first search (BFS) on a binary tree, accumulating nodes themselves.
+     * Performs a breadth-first search (bfs) on a binary tree, accumulating nodes themselves.
      * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of binary tree nodes.
      */
-    BFS(nodeOrPropertyName: 'node'): N[];
+    bfs(nodeOrPropertyName: 'node'): N[];
     /**
-     * Performs a depth-first search (DFS) traversal on a binary tree and accumulates properties of each node based on their 'id' property.
+     * Performs a depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
      * @returns An array of binary tree node IDs.
      */
-    DFS(): BinaryTreeNodeId[];
+    dfs(): BinaryTreeNodeKey[];
     /**
-     * Performs a depth-first search (DFS) traversal on a binary tree and accumulates properties of each node based on the specified property name.
+     * Performs a depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
+     * @returns An array of values corresponding to the specified property.
+     */
+    dfs(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
+    /**
+     * Performs a depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {string} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of values corresponding to the specified property.
      */
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
     /**
-     * Performs a depth-first search (DFS) traversal on a binary tree and accumulates the 'val' property of each node.
+     * Performs a depth-first search (dfs) traversal on a binary tree and accumulates the 'val' property of each node.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of 'val' properties from each node.
      */
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N[];
     /**
-     * Performs a depth-first search (DFS) traversal on a binary tree and accumulates nodes themselves.
+     * Performs a depth-first search (dfs) traversal on a binary tree and accumulates nodes themselves.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of binary tree nodes.
      */
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
     /**
-     * Performs an iterative depth-first search (DFS) traversal on a binary tree and accumulates properties of each node based on their 'id' property.
+     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
      * @returns An array of binary tree node IDs.
      */
-    DFSIterative(): BinaryTreeNodeId[];
+    dfsIterative(): BinaryTreeNodeKey[];
     /**
-     * Performs an iterative depth-first search (DFS) traversal on a binary tree and accumulates properties of each node based on the specified property name.
+     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
+     * @returns An array of values corresponding to the specified property.
+     */
+    dfsIterative(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
+    /**
+     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {string} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of values corresponding to the specified property.
      */
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
     /**
-     * Performs an iterative depth-first search (DFS) traversal on a binary tree and accumulates the 'val' property of each node.
+     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates the 'val' property of each node.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of 'val' properties from each node.
      */
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N['val'][];
     /**
-     * Performs an iterative depth-first search (DFS) traversal on a binary tree and accumulates nodes themselves.
+     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates nodes themselves.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of binary tree nodes.
      */
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
+    /**
+     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'key' property.
+     * @returns An array of binary tree node IDs.
+     */
+    levelIterative(): BinaryTreeNodeKey[];
     /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'id' property.
+     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'key' property.
      * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
      * @returns An array of binary tree node IDs.
      */
-    levelIterative(node: N | null): BinaryTreeNodeId[];
+    levelIterative(node: N | null): BinaryTreeNodeKey[];
     /**
      * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on the specified property name.
      * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
      * @param {string} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of values corresponding to the specified property.
      */
-    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
     /**
      * Performs a level-order traversal on a binary tree starting from the specified node and accumulates the 'val' property of each node.
      * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
      * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of 'val' properties from each node.
      */
-    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
+    levelIterative(node: N | null, nodeOrPropertyName: 'val'): N['val'][];
     /**
      * Performs a level-order traversal on a binary tree starting from the specified node and accumulates nodes themselves.
      * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
      * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of binary tree nodes.
      */
-    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
+    levelIterative(node: N | null, nodeOrPropertyName: 'node'): N[];
+    /**
+     * Collects nodes from a binary tree by a specified property and organizes them into levels.
+     * @returns A 2D array of AbstractBinaryTreeNodeProperty<N> objects.
+     */
+    listLevels(): BinaryTreeNodeKey[][];
     /**
      * Collects nodes from a binary tree by a specified property and organizes them into levels.
      * @param {N | null} node - The root node of the binary tree or null. If null, the function will use the root node of the current binary tree instance.
      * @returns A 2D array of AbstractBinaryTreeNodeProperty<N> objects.
      */
-    listLevels(node: N | null): BinaryTreeNodeId[][];
+    listLevels(node: N | null): BinaryTreeNodeKey[][];
     /**
      * Collects nodes from a binary tree by a specified property and organizes them into levels.
      * @param {N | null} node - The root node of the binary tree or null. If null, the function will use the root node of the current binary tree instance.
-     * @param {'id} nodeOrPropertyName - The property of the BinaryTreeNode object to collect at each level.
+     * @param {'key} nodeOrPropertyName - The property of the BinaryTreeNode object to collect at each level.
      * @returns A 2D array of values corresponding to the specified property.
      */
-    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[][];
     /**
      * Collects nodes from a binary tree by a specified property and organizes them into levels.
      * @param {N | null} node - The root node of the binary tree or null. If null, the function will use the root node of the current binary tree instance.
      * @param {'val'} nodeOrPropertyName - The property of the BinaryTreeNode object to collect at each level.
      * @returns A 2D array of 'val' properties from each node.
      */
-    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
+    listLevels(node: N | null, nodeOrPropertyName: 'val'): N['val'][][];
     /**
      * Collects nodes from a binary tree by a specified property and organizes them into levels.
      * @param {N | null} node - The root node of the binary tree or null. If null, the function will use the root node of the current binary tree instance.
      * @param {'node'} nodeOrPropertyName - The property of the BinaryTreeNode object to collect at each level.
      * @returns A 2D array of binary tree nodes.
      */
-    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
+    listLevels(node: N | null, nodeOrPropertyName: 'node'): N[][];
     /**
      * The function returns the predecessor of a given node in a binary tree.
      * @param node - The parameter `node` is a BinaryTreeNode object, representing a node in a binary tree.
@@ -412,34 +422,40 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     getPredecessor(node: N): N;
     /**
      * Time complexity is O(n)
-     * Space complexity of Iterative DFS equals to recursive DFS which is O(n) because of the stack
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
      */
     /**
      * Performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm.
      * @returns An array of binary tree node IDs.
      */
-    morris(): BinaryTreeNodeId[];
+    morris(): BinaryTreeNodeKey[];
+    /**
+     * Performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm and accumulates properties of each node based on the specified property name.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
+     * @param {'key'} nodeOrPropertyName - The name of the property to accumulate.
+     * @returns An array of values corresponding to the specified property.
+     */
+    morris(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
     /**
      * Performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm and accumulates properties of each node based on the specified property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {'id'} nodeOrPropertyName - The name of the property to accumulate.
      * @returns An array of values corresponding to the specified property.
      */
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    morris(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
     /**
      * Performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm and accumulates the 'val' property of each node.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'val'} nodeOrPropertyName - The property of the BinaryTreeNode object to collect at each level.
      * @returns An array of 'val' properties from each node.
      */
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    morris(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N[];
     /**
      * Performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm and accumulates nodes themselves.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'node'} nodeOrPropertyName - The property of the BinaryTreeNode object to collect at each level.
      * @returns An array of binary tree nodes.
      */
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    morris(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
     /**
      * The function adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter is of type `N | null`, which means it can either be a node of
@@ -456,21 +472,6 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @param {LoopType} value - The value parameter is of type LoopType.
      */
     protected _setLoopType(value: LoopType): void;
-    /**
-     * The function sets the value of the `_visitedId` property in a protected manner.
-     * @param {BinaryTreeNodeId[]} value - value is an array of BinaryTreeNodeId values.
-     */
-    protected _setVisitedId(value: BinaryTreeNodeId[]): void;
-    /**
-     * The function sets the value of the "_visitedVal" property to the given array.
-     * @param value - An array of type N.
-     */
-    protected _setVisitedVal(value: Array<N>): void;
-    /**
-     * The function sets the value of the _visitedNode property.
-     * @param {N[]} value - N[] is an array of elements of type N.
-     */
-    protected _setVisitedNode(value: N[]): void;
     /**
      * 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.
@@ -492,17 +493,17 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * a result array.
      * @param {N} cur - The current node being processed.
      * @param {(N | null | undefined)[]} result - An array that stores the matching nodes.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter is either a `BinaryTreeNodeId` or a `N`
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is either a `BinaryTreeNodeKey` or a `N`
      * type. It represents the property value that we are comparing against in the switch statement.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to compare against when pushing nodes into the `result` array. It can be either `'id'`
-     * or `'val'`. If it is not provided or is not equal to `'id'` or `'val'`, the
+     * specifies the property name to compare against when pushing nodes into the `result` array. It can be either `'key'`
+     * or `'val'`. If it is not provided or is not equal to `'key'` or `'val'`, the
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * stop after finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set to
      * `true`, the function will stop after finding the first matching node and return `true`. If `onlyOne
      * @returns a boolean value indicating whether only one matching node should be pushed into the result array.
      */
-    protected _pushByPropertyNameStopOrNot(cur: N, result: (N | null | undefined)[], nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
+    protected _pushByPropertyNameStopOrNot(cur: N, result: (N | null | undefined)[], nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
     /**
      * The function `_accumulatedByPropertyName` accumulates values from a given node based on the specified property name.
      * @param {N} node - The `node` parameter is of type `N`, which represents a node in a data structure.
@@ -512,7 +513,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     protected _accumulatedByPropertyName(node: N, nodeOrPropertyName?: NodeOrPropertyName): void;
     /**
-     * The time complexity of Morris traversal is O(n), it's may slower than others
+     * The time complexity of Morris traversal is O(n), it may slower than others
      * The space complexity  Morris traversal is O(1) because no using stack
      */
     /**