data-structure-typed 1.34.8 → 1.34.9

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

@@ -10,31 +10,22 @@ 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 key and an optional value.
+     * 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(key: BinaryTreeNodeKey, val?: V);
-    private _key;
-    get key(): BinaryTreeNodeKey;
-    set key(v: BinaryTreeNodeKey);
-    private _val;
-    get val(): V | undefined;
-    set val(value: V | undefined);
+    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,12 +45,9 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get size(): number;
     private _loopType;
     get loopType(): LoopType;
-    private _visitedKey;
-    get visitedKey(): BinaryTreeNodeKey[];
-    private _visitedVal;
-    get visitedVal(): N['val'][];
-    private _visitedNode;
-    get visitedNode(): N[];
+    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.
@@ -95,24 +83,24 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     /**
      * 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 {(BinaryTreeNodeKey | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeKey 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: (BinaryTreeNodeKey | 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 {(BinaryTreeNodeKey | N)[]} idsOrNodes - The `idsOrNodes` parameter is an array that can contain either
+     * 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: (BinaryTreeNodeKey | 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.
@@ -126,7 +114,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @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 | BinaryTreeNodeKey | 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 | BinaryTreeNodeKey | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
@@ -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).
@@ -276,80 +264,97 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     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 'key' 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(): BinaryTreeNodeKey[];
+    bfs(): BinaryTreeNodeKey[];
     /**
-     * Performs a breadth-first search (BFS) on a binary tree, accumulating properties of each node based on the specified property name.
+     * 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: 'key'): BinaryTreeNodeKey[];
+    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 'key' 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(): BinaryTreeNodeKey[];
+    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?: 'key'): BinaryTreeNodeKey[];
+    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 'key' 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(): BinaryTreeNodeKey[];
+    dfsIterative(): BinaryTreeNodeKey[];
+    /**
+     * 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.
+     * 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?: 'key'): BinaryTreeNodeKey[];
+    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 '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.
@@ -362,21 +367,26 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @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?: 'key'): BinaryTreeNodeKey[];
+    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.
@@ -389,21 +399,21 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @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?: 'key'): BinaryTreeNodeKey[][];
+    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,7 +422,7 @@ 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.
@@ -425,21 +435,27 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @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[];
+    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).
+     * @returns An array of values corresponding to the specified property.
+     */
+    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 `_visitedKey` property in a protected manner.
-     * @param {BinaryTreeNodeKey[]} value - value is an array of BinaryTreeNodeKey values.
-     */
-    protected _setVisitedKey(value: BinaryTreeNodeKey[]): 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.
@@ -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
      */
     /**