data-structure-typed 1.18.7 → 1.18.8

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

@@ -5,10 +5,10 @@
  * @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, 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
@@ -34,22 +34,20 @@ export declare abstract class AbstractBinaryTreeNode<T = number, FAMILY extends
     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);
+    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} swapNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family 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(swapNode: FAMILY): FAMILY;
+    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
@@ -57,7 +55,7 @@ export declare abstract class AbstractBinaryTreeNode<T = number, FAMILY extends
      */
     clone(): FAMILY | null;
 }
-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
@@ -80,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.
      */
@@ -137,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.
@@ -163,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.
@@ -257,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'][];