data-structure-typed 1.18.7 → 1.19.0

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

@@ -5,27 +5,39 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BST, BSTNode } from './bst';
-import type { BinaryTreeNodeId, RecursiveTreeMultiSetNode, TreeMultiSetOptions } from '../types';
-import { IBST, IBSTNode } from '../interfaces';
-export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMILY> = RecursiveTreeMultiSetNode<T>> extends BSTNode<T, FAMILY> implements IBSTNode<T, FAMILY> {
-    /**
-     * The function creates a new node in a binary tree with an optional value and count.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param {T} [val] - The `val` parameter represents the value to be stored in the node. It is an optional parameter,
-     * meaning it can be omitted when calling the `createNode` method.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
-     * node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
-     * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
-     */
-    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+import type { BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions } from '../types';
+import { BinaryTreeDeletedResult, DFSOrderPattern, NodeOrPropertyName } from '../types';
+import { ITreeMultiset, ITreeMultisetNode } from '../interfaces';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+export declare class TreeMultisetNode<T = any, NEIGHBOR extends TreeMultisetNode<T, NEIGHBOR> = TreeMultisetNodeNested<T>> extends AVLTreeNode<T, NEIGHBOR> implements ITreeMultisetNode<T, NEIGHBOR> {
+    /**
+     * 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
+     * of 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=1] - The `count` parameter is a number that represents the number of times a particular value
+     * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
+     * parameter when creating a new instance of the `BinaryTreeNode` class,
+     */
+    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
+    private _count;
+    get count(): number;
+    set count(v: number);
 }
 /**
- * The only distinction between a TreeMultiSet and a BST lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBST<N> {
-    constructor(options?: TreeMultiSetOptions);
+export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultisetNode> extends AVLTree<N> implements ITreeMultiset<N> {
+    /**
+     * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
+     * merge duplicated values.
+     * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the
+     * TreeMultiset.
+     */
+    constructor(options?: TreeMultisetOptions);
+    private _count;
+    get count(): number;
     /**
      * The function creates a new BSTNode with the given id, value, and count.
      * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
@@ -36,4 +48,161 @@ export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<numbe
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
     createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    /**
+     * The function swaps the location of two nodes in a tree data structure.
+     * @param {N} srcNode - The source node that we 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 with.
+     * @returns the `destNode` after swapping its values with the `srcNode`.
+     */
+    swapLocation(srcNode: N, destNode: N): N;
+    /**
+     * The `add` function adds a new node to a binary tree, updating the size and count properties accordingly, and
+     * balancing the tree if necessary.
+     * @param {BinaryTreeNodeId} id - The id parameter represents the identifier of the binary tree node that we want to
+     * add. It is of type BinaryTreeNodeId.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
+     * provided, it will default to `undefined`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the node
+     * with the given `id` should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
+     * @returns The `add` method returns the inserted node (`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.
+     * @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;
+    /**
+     * The `addMany` function inserts multiple items into 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.
+     */
+    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
+    /**
+     * 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 taken into account when removing it. If `ignoreCount` is set to `false
+     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     */
+    remove(nodeOrId: N | BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    /**
+     * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
+     * recursive or iterative traversal.
+     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
+     * binary tree.
+     * @returns The function `getSubTreeCount` returns an array `[number, number]`.
+     */
+    getSubTreeCount(subTreeRoot: N | null | undefined): [number, number];
+    /**
+     * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
+     * recursively or iteratively.
+     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree) or
+     * `null` if the subtree is empty.
+     * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
+     */
+    subTreeSumCount(subTreeRoot: N | BinaryTreeNodeId | null): number;
+    /**
+     * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
+     * the `count` property of each node.
+     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree), a
+     * `BinaryTreeNode` object, or `null` if the subtree is empty.
+     * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
+     * in the subtree should be increased or decreased.
+     * @returns a boolean value.
+     */
+    subTreeAddCount(subTreeRoot: N | BinaryTreeNodeId | null, delta: number): boolean;
+    /**
+     * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
+     * using a queue.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * `N`. It represents the property of the nodes that you want to search for.
+     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
+     * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
+     * to `true`, the function will return only one node. If `onlyOne`
+     * @returns an array of nodes that match the given nodeProperty.
+     */
+    getNodesByCount(nodeProperty: BinaryTreeNodeId | N, onlyOne?: boolean): N[];
+    /**
+     * The BFSCount function returns an array of counts from a breadth-first search of nodes.
+     * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
+     * BFS traversal.
+     */
+    BFSCount(): number[];
+    /**
+     * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
+     * count property of each node at that level.
+     * @param {N | null} node - The parameter `node` is of type `N | null`. This means that it can either be an instance of
+     * the class `N` or `null`.
+     * @returns a 2D array of numbers. Each inner array represents a level in the binary tree, and each number in the inner
+     * array represents the count property of a node in that level.
+     */
+    listLevelsCount(node: N | null): number[][];
+    /**
+     * The `morrisCount` function returns an array of counts for each node in a binary tree, based on a specified traversal
+     * pattern.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that specifies the
+     * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
+     * @returns The function `morrisCount` returns an array of numbers.
+     */
+    morrisCount(pattern?: 'in' | 'pre' | 'post'): number[];
+    /**
+     * The function DFSIterativeCount performs a depth-first search iteratively and returns an array of count values for
+     * each node.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter is a string that specifies the traversal order
+     * for the Depth-First Search (DFS) algorithm. It can have one of three values: 'in', 'pre', or 'post'.
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
+     * specifies whether to return the nodes or the property names during the depth-first search traversal. If it is set to
+     * `'node'`, the function will return the nodes. If it is set to `'property'`, the function will return the property
+     * @returns The DFSIterativeCount method returns an array of numbers.
+     */
+    DFSIterativeCount(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): number[];
+    /**
+     * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
+     * @param {DFSOrderPattern} [pattern] - The `pattern` parameter is an optional parameter that specifies the order in
+     * which the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
+     * @param [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is used to specify whether you want to retrieve the
+     * nodes themselves or a specific property of the nodes. If you pass `'count'` as the value for `nodeOrPropertyName`,
+     * the function will return an array of the `count` property of each node.
+     * @returns The DFSCount method returns an array of numbers representing the count property of each node in the DFS
+     * traversal.
+     */
+    DFSCount(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    /**
+     * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
+     * value than a given node.
+     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+     * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
+     */
+    lesserSumCount(beginNode: N | BinaryTreeNodeId | null): number;
+    /**
+     * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
+     * greater than a given ID by a specified delta value.
+     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be one of the following:
+     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
+     * of each node should be increased.
+     * @returns a boolean value.
+     */
+    allGreaterNodesAddCount(node: N | BinaryTreeNodeId | null, delta: number): boolean;
+    /**
+     * The clear() function clears the data and sets the count to 0.
+     */
+    clear(): void;
+    /**
+     * The function "_setCount" is used to set the value of the "_count" property.
+     * @param {number} v - number
+     */
+    protected _setCount(v: number): void;
 }