heap-typed 2.0.5 → 2.1.1

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

@@ -5,208 +5,186 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
+import { BSTOptions } from '../../types';
+import { BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
+/**
+ * RB-tree node with an extra 'count' field; keeps parent/child links.
+ * @remarks Time O(1), Space O(1)
+ * @template K
+ * @template V
+ */
 export declare class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
     parent?: TreeCounterNode<K, V>;
     /**
-     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
-     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
-     * used to identify and locate the node within the tree.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
-     * creating a new node.
-     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
-     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
-     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
-     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     * Create a tree counter node.
+     * @remarks Time O(1), Space O(1)
+     * @param key - Key of the node.
+     * @param [value] - Value associated with the key (ignored in map mode).
+     * @param [count] - Initial count for this node (default 1).
+     * @param color - Initial color ('RED' or 'BLACK').
+     * @returns New TreeCounterNode instance.
      */
     constructor(key: K, value?: V, count?: number, color?: RBTNColor);
     _left?: TreeCounterNode<K, V> | null | undefined;
+    /**
+     * Get the left child pointer.
+     * @remarks Time O(1), Space O(1)
+     * @returns Left child node, or null/undefined.
+     */
     get left(): TreeCounterNode<K, V> | null | undefined;
+    /**
+     * Set the left child and update its parent pointer.
+     * @remarks Time O(1), Space O(1)
+     * @param v - New left child node, or null/undefined.
+     * @returns void
+     */
     set left(v: TreeCounterNode<K, V> | null | undefined);
     _right?: TreeCounterNode<K, V> | null | undefined;
+    /**
+     * Get the right child pointer.
+     * @remarks Time O(1), Space O(1)
+     * @returns Right child node, or null/undefined.
+     */
     get right(): TreeCounterNode<K, V> | null | undefined;
+    /**
+     * Set the right child and update its parent pointer.
+     * @remarks Time O(1), Space O(1)
+     * @param v - New right child node, or null/undefined.
+     * @returns void
+     */
     set right(v: TreeCounterNode<K, V> | null | undefined);
 }
 /**
- *
+ * Red-Black Tree–based counter map (key → value with per-node count). Supports O(log N) updates and map-like mode.
+ * @remarks Time O(1), Space O(1)
+ * @template K
+ * @template V
+ * @template R
  */
-export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends RedBlackTree<K, V, R, MK, MV, MR> implements IBinaryTree<K, V, R, MK, MV, MR> {
+export declare class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R> implements IBinaryTree<K, V, R> {
     /**
-     * The constructor function initializes a TreeCounter object with optional initial data.
-     * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
-     * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
-     * TreeCounter with initial data.
-     * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the `TreeCounter` constructor. It can include properties such as `compareKeys` and
-     * `compareValues`, which are functions used to compare keys and values respectively.
+     * Create a TreeCounter and optionally bulk-insert items.
+     * @remarks Time O(N log N), Space O(N)
+     * @param [keysNodesEntriesOrRaws] - Iterable of keys/nodes/entries/raw items to insert.
+     * @param [options] - Options for TreeCounter (comparator, reverse, map mode).
+     * @returns New TreeCounter instance.
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: TreeCounterOptions<K, V, R>);
     protected _count: number;
     /**
-     * The function calculates the sum of the count property of all nodes in a tree structure.
-     * @returns the sum of the count property of all nodes in the tree.
+     * Get the total aggregate count across all nodes.
+     * @remarks Time O(1), Space O(1)
+     * @returns Total count.
      */
     get count(): number;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function calculates the sum of the count property of all nodes in a tree using depth-first
-     * search.
-     * @returns the sum of the count property of all nodes in the tree.
+     * Compute the total count by traversing the tree (sums node.count).
+     * @remarks Time O(N), Space O(H)
+     * @returns Total count recomputed from nodes.
      */
     getComputedCount(): number;
+    _createNode(key: K, value?: V, color?: RBTNColor, count?: number): TreeCounterNode<K, V>;
     /**
-     * The function creates a new TreeCounterNode with the specified key, value, color, and count.
-     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type representing the type of keys in the tree.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the node. It is of type `V`, which can be any data type.
-     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
-     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
-     * the tree. It is an optional parameter and is used to keep track of the number of values associated
-     * with a key in the tree.
-     * @returns A new instance of the TreeCounterNode class, casted as TreeCounterNode<K, V>.
-     */
-    createNode(key: K, value?: V, color?: RBTNColor, count?: number): TreeCounterNode<K, V>;
-    /**
-     * The function creates a new instance of a TreeCounter with the specified options and returns it.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `TreeCounter`. It is of type `TreeCounterOptions<K, V,
-     * R>`.
-     * @returns a new instance of the `TreeCounter` class, with the provided options merged with the
-     * existing `iterationType` property. The returned value is casted as `TREE`.
-     */
-    createTree(options?: TreeCounterOptions<K, V, R>): TreeCounter<K, V, R, MK, MV, MR>;
-    /**
-     * The function checks if the input is an instance of the TreeCounterNode class.
-     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
-     * an instance of the `TreeCounterNode` class.
+     * Type guard: check whether the input is a TreeCounterNode.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if the value is a TreeCounterNode.
      */
     isNode(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is TreeCounterNode<K, V>;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the add method of a class and adds a new node to a data structure, updating
-     * the count and returning a boolean indicating success.
-     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
-     * `keyNodeOrEntry` parameter can accept one of the following types:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
-     * data structure. It is an optional parameter, so it can be omitted if not needed.
-     * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
-     * be added to the data structure. By default, it is set to 1, meaning that if no value is provided
-     * for `count`, the key-value pair will be added once.
-     * @returns The method is returning a boolean value. It returns true if the addition of the new node
-     * was successful, and false otherwise.
+     * Insert or increment a node and update aggregate count.
+     * @remarks Time O(log N), Space O(1)
+     * @param keyNodeOrEntry - Key, node, or [key, value] entry to insert.
+     * @param [value] - Value when a bare key is provided (ignored in map mode).
+     * @param [count] - How much to increase the node's count (default 1).
+     * @returns True if inserted/updated; false if ignored.
      */
     add(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
-     * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
-     * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, or an entry.
-     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
-     * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
-     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
-     * `ignoreCount` is `false
-     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
+     * Delete a node (or decrement its count) and rebalance if needed.
+     * @remarks Time O(log N), Space O(1)
+     * @param keyNodeOrEntry - Key, node, or [key, value] entry identifying the node.
+     * @param [ignoreCount] - If true, remove the node regardless of its count.
+     * @returns Array of deletion results including deleted node and a rebalance hint when present.
      */
     delete(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, ignoreCount?: boolean): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[];
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The "clear" function overrides the parent class's "clear" function and also resets the count to
-     * zero.
+     * Remove all nodes and reset aggregate counters.
+     * @remarks Time O(N), Space O(1)
+     * @returns void
      */
     clear(): void;
     /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(log n)
-     *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
-     * specifies the type of iteration to use when building the balanced binary search tree. It has a
-     * default value of `this.iterationType`, which means it will use the iteration type specified by the
-     * `iterationType` property of the current object.
-     * @returns The function `perfectlyBalance` returns a boolean value. It returns `true` if the
-     * balancing operation is successful, and `false` if there are no nodes to balance.
+     * Rebuild the tree into a perfectly balanced form using in-order nodes.
+     * @remarks Time O(N), Space O(N)
+     * @param [iterationType] - Traversal style to use when constructing the balanced tree.
+     * @returns True if rebalancing succeeded (tree not empty).
      */
     perfectlyBalance(iterationType?: IterationType): boolean;
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function overrides the clone method to create a deep copy of a tree object.
-     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
-     */
-    clone(): TreeCounter<K, V, R, MK, MV, MR>;
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeCounter with
-     * modified entries based on a provided callback.
-     * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * map. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeCounterOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeCounter` instance within the `map` function. These options could
-     * include things like
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeCounter instance is being returned, which is populated with entries generated
-     * by the provided callback function.
-     */
-    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeCounterOptions<MK, MV, MR>, thisArg?: any): TreeCounter<MK, MV, MR>;
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a TreeCounterNode<K, V> object or undefined.
+     * Create a new TreeCounter by mapping each [key, value] entry.
+     * @remarks Time O(N log N), Space O(N)
+     * @template MK
+     * @template MV
+     * @template MR
+     * @param callback - Function mapping (key, value, index, tree) → [newKey, newValue].
+     * @param [options] - Options for the output tree.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new TreeCounter with mapped entries.
+     */
+    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): TreeCounter<MK, MV, MR>;
+    /**
+     * Deep copy this tree, preserving map mode and aggregate counts.
+     * @remarks Time O(N), Space O(N)
+     * @returns A deep copy of this tree.
+     */
+    clone(): this;
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @template TK
+     * @template TV
+     * @template TR
+     * @param [options] - Optional constructor options for the like-kind instance.
+     * @returns An empty like-kind instance.
+     */
+    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<BSTOptions<TK, TV, TR>>): this;
+    /**
+     * (Protected) Create a like-kind instance and seed it from an iterable.
+     * @remarks Time O(N log N), Space O(N)
+     * @template TK
+     * @template TV
+     * @template TR
+     * @param iter - Iterable used to seed the new tree.
+     * @param [options] - Options merged with the current snapshot.
+     * @returns A like-kind TreeCounter built from the iterable.
+     */
+    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | BSTNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<BSTOptions<TK, TV, TR>>): TreeCounter<TK, TV, TR>;
+    /**
+     * (Protected) Normalize input into a node plus its effective value and count.
+     * @remarks Time O(1), Space O(1)
+     * @param keyNodeOrEntry - Key, node, or [key, value] entry.
+     * @param [value] - Value used when a bare key is provided.
+     * @param [count] - Count increment to apply (default 1).
+     * @returns Tuple [node, value] where node may be undefined.
      */
     protected _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): [TreeCounterNode<K, V> | undefined, V | undefined];
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
-     * in a binary search tree.
-     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} srcNode - The `srcNode` parameter represents the source node
-     * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-     * instance of the `BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>` class.
-     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} destNode - The `destNode` parameter represents the destination
-     * node where the properties will be swapped with the source node.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     * If either `srcNode` or `destNode` is undefined, it returns undefined.
+     * (Protected) Swap keys/values/counters between the source and destination nodes.
+     * @remarks Time O(1), Space O(1)
+     * @param srcNode - Source node (or key) whose properties will be moved.
+     * @param destNode - Destination node (or key) to receive properties.
+     * @returns Destination node after swap, or undefined.
      */
     protected _swapProperties(srcNode: BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>, destNode: BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>): TreeCounterNode<K, V> | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function replaces an old node with a new node and updates the count property of the new node.
-     * @param {TreeCounterNode<K, V>} oldNode - The `oldNode` parameter is the node that you want to replace in the data
-     * structure.
-     * @param {TreeCounterNode<K, V>} newNode - The `newNode` parameter is an instance of the `TreeCounterNode<K, V>` class.
-     * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `TreeCounterNode<K, V>`.
+     * (Protected) Replace one node by another and adjust counters accordingly.
+     * @remarks Time O(1), Space O(1)
+     * @param oldNode - Node being replaced.
+     * @param newNode - Replacement node.
+     * @returns The new node after replacement.
      */
     protected _replaceNode(oldNode: TreeCounterNode<K, V>, newNode: TreeCounterNode<K, V>): TreeCounterNode<K, V>;
 }