bst-typed 1.53.9 → 1.54.1

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

@@ -6,30 +6,26 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback } from '../../types';
+import type { AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, OptNodeOrNull } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
+export declare class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
     /**
-     * The constructor function initializes a new instance of a class with a key and an optional value,
-     * and sets the height property to 0.
-     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-     * constructor. It is used to initialize the key property of the object being created.
-     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
-     * value associated with the key in the constructor.
+     * This TypeScript constructor function initializes an instance with a key and an optional value.
+     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
+     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
+     * associated value or data.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a value is not provided, it will
+     * default to `undefined`.
      */
     constructor(key: K, value?: V);
-    protected _height: number;
-    /**
-     * The function returns the value of the height property.
-     * @returns The height of the object.
-     */
-    get height(): number;
-    /**
-     * The above function sets the value of the height property.
-     * @param {number} value - The value parameter is a number that represents the new height value to be
-     * set.
-     */
-    set height(value: number);
+    parent?: AVLTreeNode<K, V>;
+    _left?: OptNodeOrNull<AVLTreeNode<K, V>>;
+    get left(): OptNodeOrNull<AVLTreeNode<K, V>>;
+    set left(v: OptNodeOrNull<AVLTreeNode<K, V>>);
+    _right?: OptNodeOrNull<AVLTreeNode<K, V>>;
+    get right(): OptNodeOrNull<AVLTreeNode<K, V>>;
+    set right(v: OptNodeOrNull<AVLTreeNode<K, V>>);
 }
 /**
  * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
@@ -40,165 +36,199 @@ export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  */
-export declare class AVLTree<K = any, V = any, R = object, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>> extends BST<K, V, R, NODE> implements IBinaryTree<K, V, R, NODE> {
+export declare class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends BST<K, V, R, MK, MV, MR> implements IBinaryTree<K, V, R, MK, MV, MR> {
     /**
-     * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
-     * entries, or raw elements.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable object that can contain either keys, nodes, entries, or raw elements. These elements will
-     * be used to initialize the AVLTree.
-     * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the AVLTree. It can include properties such as `compareFn` (a function used to compare
-     * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
-     * `nodeBuilder` (
+     * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
+     * in an iterable format.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+     * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
+     * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
+     * R>`. It is an optional parameter that allows you to specify additional options for configuring the
+     * AVL tree. These options could include things like custom comparators, initial capacity, or any
+     * other configuration settings specific
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<R | BTNRep<K, V, NODE>>, options?: AVLTreeOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V, AVLTreeNode<K, V>> | R>, options?: AVLTreeOptions<K, V, R>);
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new AVL tree node with the given key and value.
      * @param {K} key - The key parameter is of type K, which represents the key of the node being
      * created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the node being created.
      * @returns The method is returning a new instance of the AVLTreeNode class, casted as the generic
-     * type NODE.
+     * type AVLTreeNode<K, V>.
      */
-    createNode(key: K, value?: V): NODE;
+    createNode(key: K, value?: V): AVLTreeNode<K, V>;
     /**
-     * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
-     * options.
-     * @param [options] - The `options` parameter in the `createTree` function is an object that contains
-     * configuration options for creating an AVL tree. These options can include properties such as
-     * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
-     * creates a
-     * @returns An AVLTree object is being returned with the specified options and properties inherited
-     * from the current object.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function creates a new AVL tree with the specified options and returns it.
+     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
+     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
+     * being created.
+     * @returns a new AVLTree object.
      */
-    createTree(options?: AVLTreeOptions<K, V, R>): AVLTree<K, V, R, NODE>;
+    createTree(options?: AVLTreeOptions<K, V, R>): AVLTree<K, V, R, MK, MV, MR>;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
+    isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): keyNodeOrEntry is AVLTreeNode<K, V>;
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept values of type `R`, `BTNRep<K, V, NODE>`, or
-     * `RawElement`.
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
      * @returns The method is returning a boolean value.
      */
-    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean;
+    add(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
      * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
-    map<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeOptions<MK, MV, MR>, thisArg?: any): AVLTree<MK, MV, MR, AVLTreeNode<MK, MV, AVLTreeNodeNested<MK, MV>>>;
+    delete(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default map behavior of an AVLTree data structure
+     * by applying a callback function to each entry and creating a new AVLTree with the results.
+     * @param callback - A function that will be called for each entry in the AVLTree. It takes four
+     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
+     * the AVLTree itself.
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeOptions<MK, MV, MR>`. It is an optional parameter that allows you to specify additional
+     * options for the AVL tree being created during the mapping process. These options could include
+     * custom comparators, initial
+     * @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`) within the callback function. This can be useful when you want to access
+     * properties or
+     * @returns The `map` method is returning a new AVLTree instance (`newTree`) with the entries
+     * modified by the provided callback function.
+     */
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeOptions<MK, MV, MR>, thisArg?: any): AVLTree<MK, MV, MR>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns A cloned tree object is being returned.
+     */
+    clone(): AVLTree<K, V, R, MK, MV, MR>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a
      * binary search tree.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
-     * object (`NODE`) or a key-value pair (`R`) that is being swapped with another node.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
-     * `R` or an instance of `BSTNOptKeyOrNode<K, NODE>`.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} srcNode - The `srcNode` parameter represents either a node
+     * object (`AVLTreeNode<K, V>`) or a key-value pair (`R`) that is being swapped with another node.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} destNode - The `destNode` parameter is either an instance of
+     * `R` or an instance of `BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>`.
      * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
      * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
      */
-    protected _swapProperties(srcNode: R | BSTNOptKeyOrNode<K, NODE>, destNode: R | BSTNOptKeyOrNode<K, NODE>): NODE | undefined;
+    protected _swapProperties(srcNode: BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>, destNode: BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>): AVLTreeNode<K, V> | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function calculates the balance factor of a node in a binary tree.
-     * @param {NODE} node - The parameter "node" is of type "NODE", which likely represents a node in a
+     * @param {AVLTreeNode<K, V>} node - The parameter "node" is of type "AVLTreeNode<K, V>", which likely represents a node in a
      * binary tree data structure.
      * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
      * height of the left subtree from the height of the right subtree.
      */
-    protected _balanceFactor(node: NODE): number;
+    protected _balanceFactor(node: AVLTreeNode<K, V>): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function updates the height of a node in a binary tree based on the heights of its left and
      * right children.
-     * @param {NODE} node - The parameter "node" represents a node in a binary tree data structure.
+     * @param {AVLTreeNode<K, V>} node - The parameter "node" represents a node in a binary tree data structure.
      */
-    protected _updateHeight(node: NODE): void;
+    protected _updateHeight(node: AVLTreeNode<K, V>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `_balanceLL` function performs a left-left rotation to balance a binary search tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
-    protected _balanceLL(A: NODE): void;
+    protected _balanceLL(A: AVLTreeNode<K, V>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
-    protected _balanceLR(A: NODE): void;
+    protected _balanceLR(A: AVLTreeNode<K, V>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
-    protected _balanceRR(A: NODE): void;
+    protected _balanceRR(A: AVLTreeNode<K, V>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
-    protected _balanceRL(A: NODE): void;
+    protected _balanceRL(A: AVLTreeNode<K, V>): void;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {BTNRep<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
-     * `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
+     * `BTNRep<K, V, AVLTreeNode<K, V>>`.
      */
-    protected _balancePath(node: BTNRep<K, V, NODE> | R): void;
+    protected _balancePath(node: BTNRep<K, V, AVLTreeNode<K, V>>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function replaces an old node with a new node and sets the height of the new node to be the
      * same as the old node.
-     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
+     * @param {AVLTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
      * the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
+     * @param {AVLTreeNode<K, V>} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
      * the data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, with the `oldNode` and `newNode` as arguments.
      */
-    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
+    protected _replaceNode(oldNode: AVLTreeNode<K, V>, newNode: AVLTreeNode<K, V>): AVLTreeNode<K, V>;
 }