data-structure-typed 1.18.6 → 1.18.8

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

@@ -5,17 +5,26 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AbstractRecursiveBinaryTreeNode, AbstractResultsByProperty, 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 { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare abstract class AbstractBinaryTreeNode<T, FAMILY extends AbstractBinaryTreeNode<T, FAMILY> = AbstractRecursiveBinaryTreeNode<T>> implements IBinaryTreeNode<T, FAMILY> {
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
+import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from '../interfaces';
+export declare abstract class AbstractBinaryTreeNode<T = any, FAMILY extends AbstractBinaryTreeNode<T, FAMILY> = AbstractBinaryTreeNodeNested<T>> implements IAbstractBinaryTreeNode<T, FAMILY> {
+    /**
+     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
+     * @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.
+     */
+    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
     private _id;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
     private _val;
-    get val(): T;
-    set val(v: T);
+    get val(): T | undefined;
+    set val(value: T | undefined);
     private _left?;
     get left(): FAMILY | null | undefined;
     set left(v: FAMILY | null | undefined);
@@ -25,20 +34,28 @@ export declare abstract class AbstractBinaryTreeNode<T, FAMILY extends AbstractB
     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);
     private _height;
     get height(): number;
     set height(v: number);
-    abstract _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
-    swapLocation(swapNode: FAMILY): FAMILY;
+    get familyPosition(): FamilyPosition;
+    abstract createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+    /**
+     * The function swaps the location of two nodes in a binary tree.
+     * @param {FAMILY} destNode - 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(destNode: 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.
+     */
     clone(): FAMILY | null;
 }
-export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N> = AbstractBinaryTreeNode<number>> implements IBinaryTree<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
@@ -61,15 +78,15 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get autoIncrementId(): boolean;
     private _maxId;
     get maxId(): number;
-    private _isDuplicatedVal;
-    get isDuplicatedVal(): boolean;
+    private _isMergeDuplicatedVal;
+    get isMergeDuplicatedVal(): 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'], count?: number): N | null;
     /**
      * The clear function resets the state of an object by setting its properties to their initial values.
      */
@@ -92,12 +109,13 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {N | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * @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.
      */
     addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
@@ -117,24 +135,21 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     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 | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
      * @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.
+     * not be taken into account when removing it. If `ignoreCount` is set to `false
+     * @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.
@@ -143,7 +158,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * If no value is provided for `beginRoot`, the function will use the `root` property of the class instance as
      * @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.
@@ -172,7 +187,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * 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.
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (N | null | undefined)[];
+    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.
@@ -206,12 +221,16 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     getRightMost(): N | null;
     getRightMost(node: N): N;
     /**
-     * The `isBST` function checks if a binary tree is a binary search tree.
-     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
-     * | null`. It represents the root node of the binary search tree (BST) that we want to check for validity. If no node
-     * is provided, the function will default to using the root node of the BST instance that
-     * @returns The `isBST` function returns a boolean value. It returns `true` if the binary tree is a valid binary search
-     * tree, and `false` otherwise.
+     * The function `isBSTByRooted` checks if a binary tree is a binary search tree (BST) by rooted traversal.
+     * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
+     * @returns a boolean value.
+     */
+    isBSTByRooted(node: N | null): boolean;
+    /**
+     * The function checks if a binary tree is a binary search tree.
+     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
+     * search tree (BST).
+     * @returns a boolean value.
      */
     isBST(node?: N | null): boolean;
     /**
@@ -233,17 +252,19 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * provided, it defaults to `'val'`.
      * @returns a number, which is the sum of the values of the nodes 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 binary tree node. It can also be `null` if there is no subtree root.
      * @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 or decremented.
      * @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. It can be either 'id' or 'count'. If no
+     * value is provided for `propertyName`, 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'][];
@@ -327,7 +348,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * to 'id'.
      * @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 `AbstractResultsByProperty<T>`.
+     * @returns The method returns an object of type `AbstractBinaryTreeNodeProperties<T>`.
      */
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): AbstractResultsByProperty<N>;
+    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 }