directed-graph-typed 2.0.4 → 2.1.0

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

@@ -5,210 +5,178 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback, IterationType } from '../../types';
+import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
+/**
+ * AVL node with an extra 'count' field; keeps parent/child links.
+ * @remarks Time O(1), Space O(1)
+ * @template K
+ * @template V
+ */
 export declare class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
     parent?: AVLTreeCounterNode<K, V>;
     /**
-     * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
-     * of the binary tree node.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. 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.
+     * Create an AVL counter node.
+     * @remarks Time O(1), Space O(1)
+     * @param key - Key of the node.
+     * @param [value] - Associated value (ignored in map mode).
+     * @param [count] - Initial count for this node (default 1).
+     * @returns New AVLTreeCounterNode instance.
      */
     constructor(key: K, value?: V, count?: number);
     _left?: AVLTreeCounterNode<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(): AVLTreeCounterNode<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: AVLTreeCounterNode<K, V> | null | undefined);
     _right?: AVLTreeCounterNode<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(): AVLTreeCounterNode<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: AVLTreeCounterNode<K, V> | null | undefined);
 }
 /**
- * The only distinction between a AVLTreeCounter and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * AVL tree that tracks an aggregate 'count' across nodes; supports balanced insert/delete and map-like mode.
+ * @remarks Time O(1), Space O(1)
+ * @template K
+ * @template V
+ * @template R
  */
-export declare class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends AVLTree<K, V, R, MK, MV, MR> implements IBinaryTree<K, V, R, MK, MV, MR> {
+export declare class AVLTreeCounter<K = any, V = any, R extends object = object> extends AVLTree<K, V, R> implements IBinaryTree<K, V, R> {
     /**
-     * The constructor initializes a new AVLTreeCounter object with optional initial elements.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable object that can contain either keys, nodes, entries, or raw elements.
-     * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the AVLTreeCounter. It can include properties such as `compareKeys` and
-     * `compareValues` functions to define custom comparison logic for keys and values, respectively.
+     * Create a AVLTreeCounter instance
+     * @remarks Time O(n), Space O(n)
+     * @param keysNodesEntriesOrRaws
+     * @param options
+     * @returns New AVLTreeCounterNode instance.
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: AVLTreeCounterOptions<K, V, R>);
     protected _count: number;
-    /**
-     * 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.
-     */
     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, count?: number): AVLTreeCounterNode<K, V>;
     /**
-     * The function creates a new AVLTreeCounterNode with the specified key, value, 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 that can be replaced with any specific type when using the function.
-     * @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 {number} [count] - The `count` parameter represents the number of occurrences of a
-     * key-value pair in the AVLTreeCounterNode. It is an optional parameter, so it can be omitted when
-     * calling the `createNode` method. If provided, it specifies the initial count for the node.
-     * @returns a new instance of the AVLTreeCounterNode class, casted as AVLTreeCounterNode<K, V>.
-     */
-    createNode(key: K, value?: V, count?: number): AVLTreeCounterNode<K, V>;
-    /**
-     * The function creates a new AVLTreeCounter object with the specified options and returns it.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the AVLTreeCounter. It can have the following properties:
-     * @returns a new instance of the AVLTreeCounter class, with the specified options, as a TREE
-     * object.
-     */
-    createTree(options?: AVLTreeCounterOptions<K, V, R>): AVLTreeCounter<K, V, R, MK, MV, MR>;
-    /**
-     * The function checks if the input is an instance of AVLTreeCounterNode.
-     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
-     * an instance of the `AVLTreeCounterNode` class.
+     * Type guard: check whether the input is an AVLTreeCounterNode.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if the value is an AVLTreeCounterNode.
      */
     isNode(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is AVLTreeCounterNode<K, V>;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the add method of a TypeScript class to add a new node to a data structure
-     * and update the count.
-     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
-     * `keyNodeOrEntry` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`, which represents a key, node,
-     * entry, or raw element
-     * @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 the key-value pair will
-     * be added once. However, you can specify a different value for `count` if you want to add
-     * @returns a boolean value.
+     * 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 | AVLTreeCounterNode<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 overrides the delete method in a binary tree data structure, handling deletion of
-     * nodes and maintaining balance in the tree.
-     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
-     * parameter in the `delete` method is used to specify the condition for deleting a node from the
-     * binary tree. It can be a key, node, or entry that determines which
-     * node(s) should be deleted.
-     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
-     * boolean flag that determines whether to ignore the count of the node being deleted. If
-     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
-     * `ignoreCount` is set to
-     * @returns The `delete` method overrides the default delete behavior in a binary tree data
-     * structure. It takes a predicate or node to be deleted and an optional flag to ignore count. The
-     * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
-     * deleted node and whether balancing is needed in the tree.
+     * 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 | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, ignoreCount?: boolean): BinaryTreeDeleteResult<AVLTreeCounterNode<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 currently set in
-     * the 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(): AVLTreeCounter<K, V, R, MK, MV, MR>;
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeCounter
-     * 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
-     * AVLTreeCounter. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `AVLTreeCounterOptions<MK, MV, MR>`. This parameter allows you to provide additional
-     * configuration options when creating a new `AVLTreeCounter` instance within the `map` function.
-     * These options
-     * @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. This can be useful when you want to access properties
-     * or
-     * @returns The `map` method is returning a new `AVLTreeCounter` instance with the entries
-     * transformed by the provided `callback` function. Each entry in the original tree is passed to the
-     * `callback` function along with the index and the original tree itself. The transformed entries are
-     * then added to the new `AVLTreeCounter` instance, which is returned at the end.
-     */
-    map<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeCounterOptions<MK, MV, MR>, thisArg?: any): AVLTreeCounter<MK, MV, MR>;
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
-     * a node object.
-     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
-     * `keyNodeOrEntry` parameter can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `override` function. It represents the value associated with the key in the data structure. If no
-     * value is provided, it will default to `undefined`.
-     * @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 AVLTreeCounterNode<K, V> object or undefined.
+     * 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;
+    /**
+     * Create a new AVLTreeCounter 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 AVLTreeCounter with mapped entries.
+     */
+    map<MK = K, MV = V, MR extends object = object>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): AVLTreeCounter<MK, MV, MR>;
+    /**
+     * (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 extends object = R>(options?: Partial<AVLTreeCounterOptions<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 AVLTreeCounter built from the iterable.
+     */
+    protected _createLike<TK = K, TV = V, TR extends object = R>(iter?: Iterable<TK | AVLTreeCounterNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<AVLTreeCounterOptions<TK, TV, TR>>): AVLTreeCounter<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 | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): [AVLTreeCounterNode<K, V> | undefined, V | undefined];
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `_swapProperties` function swaps the properties (key, value, count, height) between two nodes
-     * in a binary search tree.
-     * @param {BSTNOptKeyOrNode<K, AVLTreeCounterNode<K, V>>} srcNode - The `srcNode` parameter represents the source node
-     * that will be swapped with the `destNode`.
-     * @param {BSTNOptKeyOrNode<K, AVLTreeCounterNode<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, AVLTreeCounterNode<K, V>>, destNode: BSTNOptKeyOrNode<K, AVLTreeCounterNode<K, V>>): AVLTreeCounterNode<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 {AVLTreeCounterNode<K, V>} oldNode - The oldNode parameter represents the node that needs to be replaced in the
-     * data structure. It is of type AVLTreeCounterNode<K, V>.
-     * @param {AVLTreeCounterNode<K, V>} newNode - The `newNode` parameter is an instance of the `AVLTreeCounterNode<K, V>` class.
-     * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `AVLTreeCounterNode<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: AVLTreeCounterNode<K, V>, newNode: AVLTreeCounterNode<K, V>): AVLTreeCounterNode<K, V>;
 }