min-heap-typed 1.50.1 → 1.50.3

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

@@ -5,12 +5,33 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BinaryTreeDeleteResult, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
-    color: RBTNColor;
+export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
+    /**
+     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
+     * color.
+     * @param {K} key - The key parameter is of type K and represents the key of the node in the
+     * Red-Black 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 instance of the Red-Black Tree Node.
+     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
+     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     */
     constructor(key: K, value?: V, color?: RBTNColor);
+    protected _color: RBTNColor;
+    /**
+     * The function returns the color value of a variable.
+     * @returns The color value stored in the protected variable `_color`.
+     */
+    get color(): RBTNColor;
+    /**
+     * The function sets the color property to the specified value.
+     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
+     */
+    set color(value: RBTNColor);
 }
 /**
  * 1. Each node is either red or black.
@@ -19,12 +40,11 @@ export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNo
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>> extends BST<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    Sentinel: N;
+export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, NODE, TREE> = RedBlackTree<K, V, NODE, RedBlackTreeNested<K, V, NODE>>> extends BST<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -32,10 +52,24 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: RBTreeOptions<K>);
-    protected _root: N;
-    get root(): N;
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K>);
+    protected _Sentinel: NODE;
+    /**
+     * The function returns the value of the `_Sentinel` property.
+     * @returns The method is returning the value of the `_Sentinel` property.
+     */
+    get Sentinel(): NODE;
+    protected _root: NODE;
+    /**
+     * The function returns the root node.
+     * @returns The root node of the data structure.
+     */
+    get root(): NODE;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
@@ -49,7 +83,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
-    createNode(key: K, value?: V, color?: RBTNColor): N;
+    createNode(key: K, value?: V, color?: RBTNColor): NODE;
     /**
      * The function creates a Red-Black Tree with the specified options and returns it.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -59,30 +93,32 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      */
     createTree(options?: RBTreeOptions<K>): TREE;
     /**
-     * The function `exemplarToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
+     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
-     * @returns a node of type N or undefined.
+     * @returns a node of type NODE or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): N | undefined;
+    keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
+     * The function checks if a given node is a real node in a Red-Black Tree.
+     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
+     * it can either be of type `NODE` or `undefined`.
+     * @returns a boolean value.
      */
-    isRealNode(node: N | undefined): node is N;
+    isRealNode(node: NODE | undefined): node is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
+     * On average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -94,13 +130,12 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * entry.
      * @param {V} [value] - The `value` parameter represents the value associated with the key that is
      * being added to the binary search tree.
-     * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
+     * @returns The method `add` returns either the newly added node (`NODE`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -112,15 +147,49 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * that you want to use to identify the node that you want to delete from the binary tree. It can be
      * of any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
      * you don't want to
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
-    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | undefined, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
+    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<NODE>[];
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `getNode` retrieves a single node from a binary tree based on a given identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value used to
+     * identify the node you want to retrieve. It can be of any type that is the return type of the `C`
+     * callback function. If the `identifier` is `undefined`, it means you want to retrieve the first
+     * node that matches the other criteria
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
+     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
+     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
+     * provided, the search will start from the root of the binary tree.
+     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
+     * iteration to be performed when searching for nodes in the binary tree. It is used in the
+     * `getNodes` method, which is called within the `getNode` method.
+     * @returns a value of type `NODE`, `null`, or `undefined`.
+     */
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: import("../../types").IterationType): NODE | null | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function sets the root node to the sentinel node and resets the size to 0.
+     */
+    clear(): void;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -134,13 +203,14 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Red-Black Tree.
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
-    getPredecessor(x: N): N;
+    getPredecessor(x: NODE): NODE;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * The function sets the root node of a tree structure and updates the parent property of the new
+     * root node.
+     * @param {NODE} v - The parameter "v" is of type "NODE", which represents a node in a data
+     * structure.
      */
-    clear(): void;
-    protected _setRoot(v: N): void;
+    protected _setRoot(v: NODE): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -150,9 +220,9 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Space Complexity: O(1)
      *
      * The function performs a left rotation on a binary tree node.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `N`, which likely represents a node in a binary tree.
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `NODE`, which likely represents a node in a binary tree.
      */
-    protected _leftRotate(x: N): void;
+    protected _leftRotate(x: NODE): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -165,7 +235,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @param {RedBlackTreeNode} x - x is a RedBlackTreeNode, which represents the node that needs to be right
      * rotated.
      */
-    protected _rightRotate(x: N): void;
+    protected _rightRotate(x: NODE): void;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -174,44 +244,44 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
-     * @param {RedBlackTreeNode} x - The parameter `x` represents a node in a Red-Black Tree (RBT).
+     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
+     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
+     * red-black tree.
      */
-    protected _fixDelete(x: N): void;
+    protected _fixInsert(k: NODE): void;
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
-     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
-     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
+     * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
+     * @param {RedBlackTreeNode} x - The parameter `x` represents a node in a Red-Black Tree (RBT).
      */
-    protected _rbTransplant(u: N, v: N): void;
+    protected _fixDelete(x: NODE): void;
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
-     * red-black tree.
+     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
+     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
+     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
      */
-    protected _fixInsert(k: N): void;
+    protected _rbTransplant(u: NODE, v: NODE): void;
     /**
      * The function replaces an old node with a new node while preserving the color of the old node.
-     * @param {N} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
-     * data structure. It is of type `N`, which is the type of the nodes in the data structure.
-     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
+     * data structure. It is of type `NODE`, which is the type of the nodes in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is the 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, passing in the `oldNode` and `newNode` as arguments.
      */
-    protected _replaceNode(oldNode: N, newNode: N): N;
+    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }