min-heap-typed 1.50.1 → 1.50.3

package/dist/data-structures/binary-tree/rb-tree.js

@@ -11,9 +11,34 @@ exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
 const types_1 = require("../../types");
 const bst_1 = require("./bst");
 class RedBlackTreeNode extends bst_1.BSTNode {
+    /**
+     * 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, value, color = types_1.RBTNColor.BLACK) {
         super(key, value);
-        this.color = color;
+        this._color = color;
+    }
+    /**
+     * The function returns the color value of a variable.
+     * @returns The color value stored in the protected variable `_color`.
+     */
+    get color() {
+        return this._color;
+    }
+    /**
+     * The function sets the color property to the specified value.
+     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
+     */
+    set color(value) {
+        this._color = value;
     }
 }
 exports.RedBlackTreeNode = RedBlackTreeNode;
@@ -28,7 +53,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * 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
@@ -38,15 +63,30 @@ class RedBlackTree extends bst_1.BST {
      */
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        this.Sentinel = new RedBlackTreeNode(NaN);
+        this._Sentinel = new RedBlackTreeNode(NaN);
         this._size = 0;
-        this._root = this.Sentinel;
+        this._root = this._Sentinel;
         if (keysOrNodesOrEntries)
             super.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the value of the `_Sentinel` property.
+     * @returns The method is returning the value of the `_Sentinel` property.
+     */
+    get Sentinel() {
+        return this._Sentinel;
+    }
+    /**
+     * The function returns the root node.
+     * @returns The root node of the data structure.
+     */
     get root() {
         return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
         return this._size;
     }
@@ -76,14 +116,14 @@ class RedBlackTree extends bst_1.BST {
         return new RedBlackTree([], Object.assign({ iterationType: this.iterationType }, options));
     }
     /**
-     * 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, value) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
         let node;
         if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
             return;
@@ -110,7 +150,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * 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.
      */
@@ -118,18 +158,20 @@ class RedBlackTree extends bst_1.BST {
         return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
     /**
-     * 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) {
-        if (node === this.Sentinel || node === undefined)
+        if (node === this._Sentinel || node === undefined)
             return false;
         return node instanceof RedBlackTreeNode;
     }
     /**
      * 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)
@@ -141,17 +183,17 @@ class RedBlackTree extends bst_1.BST {
      * 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, value) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
+        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return false;
-        newNode.left = this.Sentinel;
-        newNode.right = this.Sentinel;
+        newNode.left = this._Sentinel;
+        newNode.right = this._Sentinel;
         let y = undefined;
         let x = this.root;
-        while (x !== this.Sentinel) {
+        while (x !== this._Sentinel) {
             y = x;
             if (x) {
                 if (newNode.key < x.key) {
@@ -194,7 +236,6 @@ class RedBlackTree extends bst_1.BST {
     /**
      * 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)
@@ -206,19 +247,19 @@ class RedBlackTree extends bst_1.BST {
      * 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(identifier, callback = this._defaultOneParamCallback) {
         const ans = [];
         if (identifier === null)
             return ans;
         const helper = (node) => {
-            let z = this.Sentinel;
+            let z = this._Sentinel;
             let x, y;
-            while (node !== this.Sentinel) {
+            while (node !== this._Sentinel) {
                 if (node && callback(node) === identifier) {
                     z = node;
                 }
@@ -229,17 +270,17 @@ class RedBlackTree extends bst_1.BST {
                     node = node === null || node === void 0 ? void 0 : node.left;
                 }
             }
-            if (z === this.Sentinel) {
+            if (z === this._Sentinel) {
                 this._size--;
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === this.Sentinel) {
+            if (z.left === this._Sentinel) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === this.Sentinel) {
+            else if (z.right === this._Sentinel) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -285,14 +326,14 @@ class RedBlackTree extends bst_1.BST {
      * 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 `N` (the type of the nodes in the binary tree) and
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * 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 `N`, `null`, or `undefined`.
+     * @returns a value of type `NODE`, `null`, or `undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
@@ -301,6 +342,20 @@ class RedBlackTree extends bst_1.BST {
         beginRoot = this.ensureNode(beginRoot);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : 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() {
+        this._root = this._Sentinel;
+        this._size = 0;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -326,13 +381,11 @@ class RedBlackTree extends bst_1.BST {
         return y;
     }
     /**
-     * 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() {
-        this._root = this.Sentinel;
-        this._size = 0;
-    }
     _setRoot(v) {
         if (v) {
             v.parent = undefined;
@@ -348,13 +401,13 @@ class RedBlackTree extends bst_1.BST {
      * 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.
      */
     _leftRotate(x) {
         if (x.right) {
             const y = x.right;
             x.right = y.left;
-            if (y.left !== this.Sentinel) {
+            if (y.left !== this._Sentinel) {
                 if (y.left)
                     y.left.parent = x;
             }
@@ -388,7 +441,7 @@ class RedBlackTree extends bst_1.BST {
         if (x.left) {
             const y = x.left;
             x.left = y.right;
-            if (y.right !== this.Sentinel) {
+            if (y.right !== this._Sentinel) {
                 if (y.right)
                     y.right.parent = x;
             }
@@ -406,6 +459,63 @@ class RedBlackTree extends bst_1.BST {
             x.parent = y;
         }
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * 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.
+     */
+    _fixInsert(k) {
+        let u;
+        while (k.parent && k.parent.color === 1) {
+            if (k.parent.parent && k.parent === k.parent.parent.right) {
+                u = k.parent.parent.left;
+                if (u && u.color === 1) {
+                    u.color = types_1.RBTNColor.BLACK;
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k = k.parent.parent;
+                }
+                else {
+                    if (k === k.parent.left) {
+                        k = k.parent;
+                        this._rightRotate(k);
+                    }
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    this._leftRotate(k.parent.parent);
+                }
+            }
+            else {
+                u = k.parent.parent.right;
+                if (u && u.color === 1) {
+                    u.color = types_1.RBTNColor.BLACK;
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k = k.parent.parent;
+                }
+                else {
+                    if (k === k.parent.right) {
+                        k = k.parent;
+                        this._leftRotate(k);
+                    }
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    this._rightRotate(k.parent.parent);
+                }
+            }
+            if (k === this.root) {
+                break;
+            }
+        }
+        this.root.color = types_1.RBTNColor.BLACK;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -505,68 +615,11 @@ class RedBlackTree extends bst_1.BST {
         }
         v.parent = u.parent;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * 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.
-     */
-    _fixInsert(k) {
-        let u;
-        while (k.parent && k.parent.color === 1) {
-            if (k.parent.parent && k.parent === k.parent.parent.right) {
-                u = k.parent.parent.left;
-                if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    k = k.parent.parent;
-                }
-                else {
-                    if (k === k.parent.left) {
-                        k = k.parent;
-                        this._rightRotate(k);
-                    }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    this._leftRotate(k.parent.parent);
-                }
-            }
-            else {
-                u = k.parent.parent.right;
-                if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    k = k.parent.parent;
-                }
-                else {
-                    if (k === k.parent.right) {
-                        k = k.parent;
-                        this._leftRotate(k);
-                    }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    this._rightRotate(k.parent.parent);
-                }
-            }
-            if (k === this.root) {
-                break;
-            }
-        }
-        this.root.color = types_1.RBTNColor.BLACK;
-    }
     /**
      * 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.

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

@@ -7,13 +7,90 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
-    start: number;
-    end: number;
-    value: SegmentTreeNodeVal | undefined;
-    sum: number;
-    left: SegmentTreeNode | undefined;
-    right: SegmentTreeNode | undefined;
+    /**
+     * The constructor initializes the properties of a SegmentTreeNode object.
+     * @param {number} start - The `start` parameter represents the starting index of the segment covered
+     * by this node in a segment tree.
+     * @param {number} end - The `end` parameter represents the end index of the segment covered by this
+     * node in a segment tree.
+     * @param {number} sum - The `sum` parameter represents the sum of the values in the range covered by
+     * the segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} [value] - The `value` parameter is an optional parameter
+     * of type `SegmentTreeNodeVal`. It represents the value associated with the segment tree node.
+     */
     constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | undefined);
+    protected _start: number;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
+    get start(): number;
+    /**
+     * The above function sets the value of the "start" property.
+     * @param {number} value - The value parameter is of type number.
+     */
+    set start(value: number);
+    protected _end: number;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
+    get end(): number;
+    /**
+     * The above function sets the value of the "end" property.
+     * @param {number} value - The value parameter is a number that represents the new value for the end
+     * property.
+     */
+    set end(value: number);
+    protected _value: SegmentTreeNodeVal | undefined;
+    /**
+     * The function returns the value of a segment tree node.
+     * @returns The value being returned is either a `SegmentTreeNodeVal` object or `undefined`.
+     */
+    get value(): SegmentTreeNodeVal | undefined;
+    /**
+     * The function sets the value of a segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} value - The `value` parameter is of type
+     * `SegmentTreeNodeVal` or `undefined`.
+     */
+    set value(value: SegmentTreeNodeVal | undefined);
+    protected _sum: number;
+    /**
+     * The function returns the value of the sum property.
+     * @returns The method is returning the value of the variable `_sum`.
+     */
+    get sum(): number;
+    /**
+     * The above function sets the value of the sum property.
+     * @param {number} value - The parameter "value" is of type "number".
+     */
+    set sum(value: number);
+    protected _left: SegmentTreeNode | undefined;
+    /**
+     * The function returns the left child of a segment tree node.
+     * @returns The `left` property of the `SegmentTreeNode` object is being returned. It is of type
+     * `SegmentTreeNode` or `undefined`.
+     */
+    get left(): SegmentTreeNode | undefined;
+    /**
+     * The function sets the value of the left property of a SegmentTreeNode object.
+     * @param {SegmentTreeNode | undefined} value - The value parameter is of type SegmentTreeNode or
+     * undefined.
+     */
+    set left(value: SegmentTreeNode | undefined);
+    protected _right: SegmentTreeNode | undefined;
+    /**
+     * The function returns the right child of a segment tree node.
+     * @returns The `getRight()` method is returning a value of type `SegmentTreeNode` or `undefined`.
+     */
+    get right(): SegmentTreeNode | undefined;
+    /**
+     * The function sets the right child of a segment tree node.
+     * @param {SegmentTreeNode | undefined} value - The `value` parameter is of type `SegmentTreeNode |
+     * undefined`. This means that it can accept either a `SegmentTreeNode` object or `undefined` as its
+     * value.
+     */
+    set right(value: SegmentTreeNode | undefined);
 }
 export declare class SegmentTree {
     /**
@@ -27,12 +104,28 @@ export declare class SegmentTree {
      */
     constructor(values: number[], start?: number, end?: number);
     protected _values: number[];
+    /**
+     * The function returns an array of numbers.
+     * @returns An array of numbers is being returned.
+     */
     get values(): number[];
     protected _start: number;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
     get start(): number;
     protected _end: number;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
     get end(): number;
     protected _root: SegmentTreeNode | undefined;
+    /**
+     * The function returns the root node of a segment tree.
+     * @returns The `root` property of the class `SegmentTreeNode` or `undefined` if it is not defined.
+     */
     get root(): SegmentTreeNode | undefined;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning