data-structure-typed 1.18.7 → 1.19.0

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

@@ -5,67 +5,61 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AbstractBinaryTreeNodeProperties, AbstractRecursiveBinaryTreeNode, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../types';
+import type { AbstractBinaryTreeNodeNested, AbstractBinaryTreeNodeProperties, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../types';
 import { AbstractBinaryTreeOptions, FamilyPosition, LoopType } from '../types';
 import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from '../interfaces';
-export declare abstract class AbstractBinaryTreeNode<T = number, FAMILY extends AbstractBinaryTreeNode<T, FAMILY> = AbstractRecursiveBinaryTreeNode<T>> implements IAbstractBinaryTreeNode<T, FAMILY> {
+export declare abstract class AbstractBinaryTreeNode<T = any, NEIGHBOR extends AbstractBinaryTreeNode<T, NEIGHBOR> = AbstractBinaryTreeNodeNested<T>> implements IAbstractBinaryTreeNode<T, NEIGHBOR> {
     /**
-     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
+     * 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
-     * for the binary tree node.
-     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
-     * tree node. If no value is provided, it will be `undefined`.
-     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of times the
-     * value `val` appears in the binary tree node. If the `count` parameter is not provided, it defaults to 1.
+     * of the binary tree node. It is used to distinguish one node from another in the binary tree.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value that will be
+     * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
-    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
+    constructor(id: BinaryTreeNodeId, val?: T);
     private _id;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
     private _val;
     get val(): T | undefined;
     set val(value: T | undefined);
-    private _left?;
-    get left(): FAMILY | null | undefined;
-    set left(v: FAMILY | null | undefined);
-    private _right?;
-    get right(): FAMILY | null | undefined;
-    set right(v: FAMILY | null | 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(): FAMILY | null | undefined;
-    set parent(v: FAMILY | null | undefined);
-    private _familyPosition;
-    get familyPosition(): FamilyPosition;
-    set familyPosition(v: FamilyPosition);
-    private _count;
-    get count(): number;
-    set count(v: number);
+    get parent(): NEIGHBOR | null | undefined;
+    set parent(v: NEIGHBOR | null | undefined);
     private _height;
     get height(): number;
     set height(v: number);
-    abstract createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
-    /**
-     * The function swaps the location of two nodes in a binary tree.
-     * @param {FAMILY} swapNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family tree.
-     * @returns the `swapNode` object after swapping its properties with the properties of `this` object.
-     */
-    swapLocation(swapNode: FAMILY): FAMILY;
     /**
-     * The `clone` function returns a new instance of the `FAMILY` class with the same `id`, `val`, and `count` properties.
-     * @returns The `clone()` method is returning a new instance of the `FAMILY` class with the same `id`, `val`, and
-     * `count` values as the current instance.
+     * The function determines the position of a node in a family tree structure.
+     * @returns a value of type `FamilyPosition`.
      */
-    clone(): FAMILY | null;
+    get familyPosition(): FamilyPosition;
 }
-export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N> = AbstractBinaryTreeNode<number>> implements IAbstractBinaryTree<N> {
+export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N> = AbstractBinaryTreeNode> implements IAbstractBinaryTree<N> {
     /**
      * The protected constructor initializes the options for an abstract binary tree.
      * @param {AbstractBinaryTreeOptions} [options] - An optional object that contains configuration options for the binary
      * tree.
      */
     protected constructor(options?: AbstractBinaryTreeOptions);
+    private _root;
+    get root(): N | null;
+    private _size;
+    get size(): number;
     private _loopType;
     get loopType(): LoopType;
+    private _autoIncrementId;
+    get autoIncrementId(): boolean;
+    private _maxId;
+    get maxId(): number;
+    private _isMergeDuplicatedVal;
+    get isMergeDuplicatedVal(): boolean;
     private _visitedId;
     get visitedId(): BinaryTreeNodeId[];
     private _visitedVal;
@@ -76,21 +70,17 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get visitedCount(): number[];
     private _visitedLeftSum;
     get visitedLeftSum(): number[];
-    private _autoIncrementId;
-    get autoIncrementId(): boolean;
-    private _maxId;
-    get maxId(): number;
-    private _isDuplicatedVal;
-    get isDuplicatedVal(): boolean;
-    private _root;
-    get root(): N | null;
-    private _size;
-    get size(): number;
-    private _count;
-    get count(): number;
-    abstract createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    abstract createNode(id: BinaryTreeNodeId, 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.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
+     * be swapped to.
+     * @returns The `destNode` is being returned.
+     */
+    swapLocation(srcNode: N, destNode: N): N;
     /**
-     * The clear function resets the state of an object by setting its properties to their initial values.
+     * The clear() function resets the root, size, and maxId properties to their initial values.
      */
     clear(): void;
     /**
@@ -99,126 +89,121 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     isEmpty(): boolean;
     /**
-     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
-     * already exists.
-     * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
-     * identify each node in the binary tree.
-     * @param {N} val - The value to be inserted into the binary tree.
-     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
-     * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `add` returns a `N` object if a new node is inserted, or `null` if no new node
-     * is inserted, or `undefined` if the insertion fails.
+     * The `add` function adds a new node to a binary tree, updating the value of an existing node if it already exists.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
+     * provided, the default value will be the same as the `id` parameter.
+     * @param {number} [count] - The `count` parameter is an optional number that represents the number of times the value
+     * should be added to the binary tree. If not provided, the default value is `undefined`.
+     * @returns The function `add` returns either a `BinaryTreeNode` object (`N`), `null`, or `undefined`.
      */
     add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
     /**
-     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * The function adds a new node to the left or right child of a parent node, updating the size of the tree if
+     * necessary.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
      * either a node object (`N`) or `null`.
      * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
      * child.
-     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
-     * `undefined` in certain cases.
+     * @returns either the left child node, the right child node, or undefined.
      */
     addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
-     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @param {N[] | Array<N['val']>} data - The `data` parameter can be either an array of `N` objects or an array of
+     * `N['val']` values.
+     * @returns The function `addMany` returns an array of values of type `N | null | undefined`.
      */
     addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
     /**
-     * The `fill` function clears the current data and inserts new data, returning a boolean indicating if the insertion
-     * was successful.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
-     * @returns The method is returning a boolean value.
+     * The `fill` function clears the current data and adds new data, returning a boolean indicating if the operation was
+     * successful.
+     * @param {N[] | Array<N['val']>} data - The `data` parameter can be either an array of objects or an array of arrays.
+     * Each object or array should have a property called `val`.
+     * @returns a boolean value.
      */
     fill(data: N[] | Array<N['val']>): boolean;
     /**
-     * The function removes a node from a binary tree and returns information about the deleted node.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to remove.
-     * It is of type `BinaryTreeNodeId`.
+     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * 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 {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
-     * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
-     * not be decremented and the overall count of the binary tree will not be updated. If `
-     * @returns An array of objects is being returned. Each object in the array has two properties: "deleted" and
-     * "needBalanced". The "deleted" property contains the deleted node or undefined if no node was deleted. The
-     * "needBalanced" property is always null.
+     * whether to ignore the count of the nodes in the binary tree. If `ignoreCount` is set to `true`, the count of the
+     * nodes in the binary tree will not be updated after removing a node. If `ignoreCount`
+     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    remove(nodeOrId: N | BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
-     * The function calculates the depth of a binary tree node by traversing its parent nodes.
-     * @param node - N - This is the node for which we want to calculate the depth. It is a generic type,
-     * meaning it can represent any type of data that we want to store in the node.
-     * @returns The depth of the given binary tree node.
+     * 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:
+     * @returns the depth of the given node or binary tree.
      */
-    getDepth(node: N): number;
+    getDepth(beginRoot: N | BinaryTreeNodeId | null): number;
     /**
-     * The `getHeight` function calculates the maximum height of a binary tree using either a recursive or iterative
-     * approach.
-     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `N | null`. It represents the starting node from which to calculate the height of the binary tree.
-     * If no value is provided for `beginRoot`, the function will use the `root` property of the class instance as
+     * 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
+     * node), or `null`.
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: N | null): number;
+    getHeight(beginRoot?: N | BinaryTreeNodeId | null): number;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
      * approach.
-     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `N | null`. It represents the starting node from which to calculate the minimum height of the binary
-     * tree. If no value is provided for `beginRoot`, the function will use the root node of the binary tree.
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It
+     * represents the starting node from which to calculate the minimum height of a binary tree. If no value is provided
+     * for `beginRoot`, the `this.root` property is used as the default value.
      * @returns The function `getMinHeight` returns the minimum height of the binary tree.
      */
     getMinHeight(beginRoot?: N | null): number;
     /**
-     * The function checks if a binary tree is balanced by comparing the minimum height and the maximum height of the tree.
-     * @param {N | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
-     * of type `N | null`, which means it can either be a `BinaryTreeNode` object or `null`.
+     * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the height of the
+     * tree.
+     * @param {N | null} [beginRoot] - The parameter `beginRoot` is of type `N` or `null`. It represents the root node of a
+     * tree or null if the tree is empty.
      * @returns The method is returning a boolean value.
      */
-    isBalanced(beginRoot?: N | null): boolean;
+    isPerfectlyBalanced(beginRoot?: N | null): boolean;
     /**
-     * The function `getNodes` returns an array of binary tree nodes that match a given property value, with options for
-     * searching recursively or iteratively.
+     * 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
      * 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'.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-     * return only one node that matches the `nodeProperty` or `propertyName` criteria. If `onlyOne` is set to `true`, the
-     * function will stop traversing the tree and return the first matching node. If `
-     * @returns The function `getNodes` returns an array of `N | null | undefined` objects.
+     * 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[];
     /**
-     * The function checks if a binary tree node has a specific property or if any node in the tree has a specific
-     * property.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `N`. It represents the property of a binary tree node that you want to check.
+     * 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`.
+     * 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 check for in the nodes.
+     * specifies the name of the property to be checked in the nodes. If not provided, it defaults to 'id'.
      * @returns a boolean value.
      */
     has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
-     * The function returns the first binary tree node that matches the given property name and value, or null if no match
-     * is found.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `N`. It represents the property of the binary tree node that you want to search for.
+     * 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`.
+     * 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 of the binary tree node to search for. If not provided, it defaults to `'id'`.
-     * @returns a BinaryTreeNode object or null.
+     * 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'`.
+     * @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;
     /**
-     * The function getPathToRoot returns an array of BinaryTreeNode objects representing the path from a given node to the
-     * root of a binary tree.
-     * @param node - The `node` parameter is a BinaryTreeNode object.
-     * @returns The function `getPathToRoot` returns an array of `N` objects, representing the path from
-     * the given `node` to the root of the binary tree.
+     * The function getPathToRoot takes a node and returns an array of nodes representing the path from the given node to
+     * the root node.
+     * @param {N} node - The parameter `node` represents a node in a tree data structure.
+     * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
     getPathToRoot(node: N): N[];
     getLeftMost(): N | null;
@@ -226,7 +211,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     getRightMost(): N | null;
     getRightMost(node: N): N;
     /**
-     * The function `isBSTByRooted` checks if a binary tree is a binary search tree (BST) by rooted traversal.
+     * 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).
      * @returns a boolean value.
      */
@@ -239,60 +224,53 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     isBST(node?: N | null): boolean;
     /**
-     * The function calculates the size and count of a subtree in a binary tree using either recursive or iterative
-     * traversal.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter is the root node of a binary
-     * tree.
-     * @returns The function `getSubTreeSizeAndCount` returns an array `[number, number]`. The first element of the array
-     * represents the size of the subtree, and the second element represents the count of the nodes in the subtree.
+     * The function calculates the size of a subtree by traversing it either recursively or iteratively.
+     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
+     * binary tree.
+     * @returns the size of the subtree rooted at `subTreeRoot`.
      */
-    getSubTreeSizeAndCount(subTreeRoot: N | null | undefined): [number, number];
+    getSubTreeSize(subTreeRoot: N | null | undefined): number;
     /**
-     * The function `subTreeSum` calculates the sum of a specified property in a binary tree, either recursively or
-     * iteratively.
-     * @param subTreeRoot - The subTreeRoot parameter is the root node of the subtree for which you want to calculate the
-     * sum.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the `BinaryTreeNode` object to use for calculating the sum. If `propertyName` is not
-     * provided, it defaults to `'val'`.
-     * @returns a number, which is the sum of the values of the nodes in the subtree rooted at `subTreeRoot`.
+     * 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
+     * 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'.
+     * @returns a number, which is the sum of the values of the specified property in the subtree rooted at `subTreeRoot`.
      */
-    subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
+    subTreeSum(subTreeRoot: N | BinaryTreeNodeId | null, propertyName?: BinaryTreeNodePropertyName): number;
     /**
-     * The function `subTreeAdd` adds a specified delta value to a property of each node in a binary tree.
-     * @param subTreeRoot - The `subTreeRoot` parameter is the root node of the subtree where the values will be modified.
+     * 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
+     * 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 increased or decreased.
+     * each node in the subtree should be incremented.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the `BinaryTreeNode` that should be modified. It defaults to `'id'` if not provided.
-     * @returns a boolean value, which is `true`.
+     * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'id'.
+     * @returns a boolean value.
      */
-    subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    subTreeAdd(subTreeRoot: N | BinaryTreeNodeId | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     BFS(): BinaryTreeNodeId[];
     BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
     BFS(nodeOrPropertyName: 'val'): N['val'][];
     BFS(nodeOrPropertyName: 'node'): N[];
-    BFS(nodeOrPropertyName: 'count'): number[];
     DFS(): BinaryTreeNodeId[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
     DFSIterative(): BinaryTreeNodeId[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
     levelIterative(node: N | null): BinaryTreeNodeId[];
     levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
     levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
     levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
-    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
     listLevels(node: N | null): BinaryTreeNodeId[][];
     listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
     listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
     listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
-    listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
     /**
      * 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.
@@ -302,56 +280,109 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     morris(): BinaryTreeNodeId[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative DFS equals to recursive DFS which is O(n) because of the stack
+     */
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    /**
+     * The function sets the loop type for a protected variable.
+     * @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 value of the visitedCount property.
+     * @param {number[]} value - The value parameter is an array of numbers.
+     */
     protected setVisitedCount(value: number[]): void;
+    /**
+     * The function sets the value of the `_visitedLeftSum` property to the provided array.
+     * @param {number[]} value - An array of numbers that represents the visited left sum.
+     */
     protected _setVisitedLeftSum(value: number[]): void;
+    /**
+     * The function sets the value of the _autoIncrementId property.
+     * @param {boolean} value - The value parameter is a boolean that determines whether the id should be automatically
+     * incremented or not. If value is true, the id will be automatically incremented. If value is false, the id will not
+     * be automatically incremented.
+     */
     protected _setAutoIncrementId(value: boolean): void;
+    /**
+     * The function sets the maximum ID value.
+     * @param {number} value - The value parameter is a number that represents the new maximum ID value.
+     */
     protected _setMaxId(value: number): void;
+    /**
+     * The function sets the value of a protected property called "_isMergeDuplicatedVal".
+     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedVal
+     * property should be set to true or false.
+     */
     protected _setIsDuplicatedVal(value: boolean): 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.
+     * @param {N | null} v - The parameter `v` is of type `N | null`, which means it can either be of type `N` or `null`.
+     */
     protected _setRoot(v: N | null): void;
+    /**
+     * The function sets the size of a protected variable.
+     * @param {number} v - number
+     */
     protected _setSize(v: number): void;
-    protected _setCount(v: number): void;
     /**
-     * The function resets the values of several arrays used for tracking visited nodes and their properties.
+     * The function `_resetResults` resets the values of several arrays used for tracking visited nodes and their
+     * properties.
      */
     protected _resetResults(): void;
     /**
      * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to
      * a result array.
-     * @param cur - The current binary tree node that is being checked.
-     * @param {(N | null | undefined)[]} result - An array that stores the matching nodes found during the
-     * traversal.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter is the value that we are searching for in
-     * the binary tree nodes. It can be either the `id`, `count`, or `val` property of the node.
+     * @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`
+     * 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 of the `BinaryTreeNode` object that you want to compare with the `nodeProperty` value. It can
-     * be one of the following values: 'id', 'count', or 'val'. If no `propertyName` is provided,
+     * 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
      * @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 or not a node was pushed into the result array.
+     * @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;
     /**
-     * The function `_accumulatedByPropertyName` pushes a property value of a binary tree node into an array based on the
-     * provided property name or a default property name.
-     * @param node - The `node` parameter is of type `N`, which represents a node in a binary tree.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
-     * can be either a string representing a property name or a reference to a node object. If it is a string, it specifies
-     * the property name of the node that should be accumulated. If it is a node object, it specifies the node itself
+     * 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.
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
+     * can be either a string representing a property name or a reference to a `Node` object. If it is a string, it
+     * specifies the property name to be used for accumulating values. If it is a `Node` object, it specifies
      */
     protected _accumulatedByPropertyName(node: N, nodeOrPropertyName?: NodeOrPropertyName): void;
     /**
-     * The function `_getResultByPropertyName` returns different results based on the provided property name or defaulting
-     * to 'id'.
+     * The time complexity of Morris traversal is O(n), it's may slower than others
+     * The space complexity  Morris traversal is O(1) because no using stack
+     */
+    /**
+     * The function `_getResultByPropertyName` returns the corresponding property value based on the given node or property
+     * name.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
-     * can accept a value of type `NodeOrPropertyName`.
-     * @returns The method returns an object of type `AbstractBinaryTreeNodeProperties<T>`.
+     * can accept either a `NodeOrPropertyName` type or be undefined.
+     * @returns The method `_getResultByPropertyName` returns an instance of `AbstractBinaryTreeNodeProperties<N>`.
      */
     protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 }