data-structure-typed 1.37.3 → 1.37.5

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

@@ -21,72 +21,80 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     constructor(options?: AVLTreeOptions);
     /**
-     * The `_swap` function swaps the location of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that you want to _swap with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
-     * be swapped to.
-     * @returns The `destNode` is being returned.
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
     protected _swap(srcNode: N, destNode: N): N;
     /**
-     * The function creates a new AVL tree node with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
-     * that will be stored in the node.
+     * The function creates a new AVL tree node with the specified key and value.
+     * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+     * the new node. It is used to determine the position of the node in the binary search tree.
+     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It is of
+     * type `N['val']`, which means it can be any value that is assignable to the `val` property of the
+     * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
-     * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
-     * @param keyOrNode - The `keyOrNode` parameter is either a key or a node that needs to be added to the binary tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
-     * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
-     * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
+     * The function overrides the add method of a binary tree node and balances the tree after inserting
+     * a new node.
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
+     * `BinaryTreeNodeKey` or a `N` (which represents a node in the binary tree) or `null`.
+     * @param [val] - The `val` parameter is the value that you want to assign to the new node that you
+     * are adding to the binary search tree.
+     * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
     /**
-     * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after deletion.
+     * The function overrides the delete method of a binary tree and balances the tree after deleting a
+     * node if necessary.
+     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
+     * (`N`) or a key value (`BinaryTreeNodeKey`).
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
-     * @param nodeOrKey - The `nodeOrKey` parameter is either a node or a key that needs to be deleted from the binary tree.
      */
     delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
-     * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
-     * height of its right subtree.
-     * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
-     * @returns The balance factor of the given AVL tree node.
+     * The function calculates the balance factor of a node in a binary tree.
+     * @param {N} node - The parameter "node" 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: N): number;
     /**
-     * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
-     * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
+     * The function updates the height of a node in a binary tree based on the heights of its left and
+     * right children.
+     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
      */
     protected _updateHeight(node: N): void;
     /**
-     * The `_balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
-     * each node in the path from the given node to the root.
-     * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
+     * 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 {N} node - The `node` parameter in the `_balancePath` function represents the node in the
+     * AVL tree that needs to be balanced.
      */
     protected _balancePath(node: N): void;
     /**
-     * The `_balanceLL` function performs a left-left rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
+     * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     protected _balanceLL(A: N): void;
     /**
-     * The `_balanceLR` function performs a left-right rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
+     * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     protected _balanceLR(A: N): void;
     /**
-     * The `_balanceRR` function performs a right-right rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
+     * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     protected _balanceRR(A: N): void;
     /**
-     * The `_balanceRL` function performs a right-left rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
+     * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     protected _balanceRL(A: N): void;
 }

package/lib/data-structures/binary-tree/avl-tree.js

@@ -23,11 +23,12 @@ export class AVLTree extends BST {
         super(options);
     }
     /**
-     * The `_swap` function swaps the location of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that you want to _swap with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
-     * be swapped to.
-     * @returns The `destNode` is being returned.
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
     _swap(srcNode, destNode) {
         const { key, val, height } = destNode;
@@ -44,22 +45,25 @@ export class AVLTree extends BST {
         return destNode;
     }
     /**
-     * The function creates a new AVL tree node with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
-     * that will be stored in the node.
+     * The function creates a new AVL tree node with the specified key and value.
+     * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+     * the new node. It is used to determine the position of the node in the binary search tree.
+     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It is of
+     * type `N['val']`, which means it can be any value that is assignable to the `val` property of the
+     * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
     createNode(key, val) {
         return new AVLTreeNode(key, val);
     }
     /**
-     * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
-     * @param keyOrNode - The `keyOrNode` parameter is either a key or a node that needs to be added to the binary tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
-     * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
-     * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
+     * The function overrides the add method of a binary tree node and balances the tree after inserting
+     * a new node.
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
+     * `BinaryTreeNodeKey` or a `N` (which represents a node in the binary tree) or `null`.
+     * @param [val] - The `val` parameter is the value that you want to assign to the new node that you
+     * are adding to the binary search tree.
+     * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNode, val) {
         // TODO support node as a param
@@ -69,9 +73,11 @@ export class AVLTree extends BST {
         return inserted;
     }
     /**
-     * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after deletion.
+     * The function overrides the delete method of a binary tree and balances the tree after deleting a
+     * node if necessary.
+     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
+     * (`N`) or a key value (`BinaryTreeNodeKey`).
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
-     * @param nodeOrKey - The `nodeOrKey` parameter is either a node or a key that needs to be deleted from the binary tree.
      */
     delete(nodeOrKey) {
         const deletedResults = super.delete(nodeOrKey);
@@ -83,10 +89,10 @@ export class AVLTree extends BST {
         return deletedResults;
     }
     /**
-     * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
-     * height of its right subtree.
-     * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
-     * @returns The balance factor of the given AVL tree node.
+     * The function calculates the balance factor of a node in a binary tree.
+     * @param {N} node - The parameter "node" 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.
      */
     _balanceFactor(node) {
         if (!node.right)
@@ -99,8 +105,9 @@ export class AVLTree extends BST {
             return node.right.height - node.left.height;
     }
     /**
-     * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
-     * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
+     * The function updates the height of a node in a binary tree based on the heights of its left and
+     * right children.
+     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
      */
     _updateHeight(node) {
         if (!node.left && !node.right)
@@ -115,9 +122,10 @@ export class AVLTree extends BST {
             node.height = 1 + Math.max(node.right.height, node.left.height);
     }
     /**
-     * The `_balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
-     * each node in the path from the given node to the root.
-     * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
+     * 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 {N} node - The `node` parameter in the `_balancePath` function represents the node in the
+     * AVL tree that needs to be balanced.
      */
     _balancePath(node) {
         const path = this.getPathToRoot(node, false); // first O(log n) + O(log n)
@@ -159,8 +167,8 @@ export class AVLTree extends BST {
         }
     }
     /**
-     * The `_balanceLL` function performs a left-left rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
+     * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceLL(A) {
         const parentOfA = A.parent;
@@ -193,8 +201,8 @@ export class AVLTree extends BST {
             this._updateHeight(B);
     }
     /**
-     * The `_balanceLR` function performs a left-right rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
+     * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceLR(A) {
         const parentOfA = A.parent;
@@ -242,8 +250,8 @@ export class AVLTree extends BST {
         C && this._updateHeight(C);
     }
     /**
-     * The `_balanceRR` function performs a right-right rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
+     * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceRR(A) {
         const parentOfA = A.parent;
@@ -277,8 +285,8 @@ export class AVLTree extends BST {
         B && this._updateHeight(B);
     }
     /**
-     * The `_balanceRL` function performs a right-left rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
+     * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceRL(A) {
         const parentOfA = A.parent;

package/lib/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -1,46 +1,144 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 export declare class BinaryIndexedTree {
+    protected readonly _freq: number;
+    protected readonly _max: number;
     /**
-     * The constructor initializes an array with a specified length and fills it with zeros.
-     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
-     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
-     * The size of the sum tree array is `n + 1` because
-     */
-    constructor(n: number);
-    private _sumTree;
-    get sumTree(): number[];
-    static lowBit(x: number): number;
-    /**
-     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
-     * its ancestors.
-     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
-     * updated.
-     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
-     * at index "i" in the "_sumTree" array.
-     */
-    update(i: number, delta: number): void;
-    /**
-     * The function calculates the prefix sum of an array using a binary indexed tree.
-     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
-     * array for which we want to calculate the prefix sum.
-     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
-     * `i`.
-     */
-    getPrefixSum(i: number): number;
-    /**
-     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
-     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
-     * sum.
-     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
-     * the sum.
-     * @returns the sum of the elements in the range specified by the start and end indices.
-     */
-    getRangeSum(start: number, end: number): number;
-    protected _setSumTree(value: number[]): void;
+     * The constructor initializes the properties of an object, including default frequency, maximum
+     * value, a freqMap data structure, the most significant bit, and the count of negative frequencies.
+     * @param  - - `frequency`: The default frequency value. It is optional and has a default
+     * value of 0.
+     */
+    constructor({ frequency, max }: {
+        frequency?: number;
+        max: number;
+    });
+    protected _freqMap: Record<number, number>;
+    get freqMap(): Record<number, number>;
+    set freqMap(value: Record<number, number>);
+    protected _msb: number;
+    get msb(): number;
+    set msb(value: number);
+    protected _negativeCount: number;
+    get negativeCount(): number;
+    set negativeCount(value: number);
+    get freq(): number;
+    get max(): number;
+    /**
+     * The function "readSingle" reads a single number from a specified index.
+     * @param {number} index - The `index` parameter is a number that represents the index of an element in a
+     * collection or array.
+     * @returns a number.
+     */
+    readSingle(index: number): number;
+    /**
+     * The "update" function updates the value at a given index by adding a delta and triggers a callback
+     * to notify of the change.
+     * @param {number} position - The `index` parameter represents the index of the element that needs to be
+     * updated in the data structure.
+     * @param {number} change - The "delta" parameter represents the change in value that needs to be
+     * applied to the frequency at the specified index.
+     */
+    update(position: number, change: number): void;
+    /**
+     * The function "writeSingle" checks the index and writes a single value with a given frequency.
+     * @param {number} index - The `index` parameter is a number that represents the index of an element. It
+     * is used to identify the specific element that needs to be written.
+     * @param {number} freq - The `freq` parameter represents the frequency value that needs to be
+     * written.
+     */
+    writeSingle(index: number, freq: number): void;
+    /**
+     * The read function takes a count parameter, checks if it is an integer, and returns the result of
+     * calling the _read function with the count parameter clamped between 0 and the maximum value.
+     * @param {number} count - The `count` parameter is a number that represents the number of items to
+     * read.
+     * @returns a number.
+     */
+    read(count: number): number;
+    /**
+     * The function returns the lower bound of a non-descending sequence that sums up to a given number.
+     * @param {number} sum - The `sum` parameter is a number that represents the target sum that we want
+     * to find in the sequence.
+     * @returns The lowerBound function is returning a number.
+     */
+    lowerBound(sum: number): number;
+    /**
+     * The upperBound function returns the index of the first element in a sequence that is greater than
+     * or equal to a given sum.
+     * @param {number} sum - The "sum" parameter is a number that represents the target sum that we want
+     * to find in the sequence.
+     * @returns The upperBound function is returning a number.
+     */
+    upperBound(sum: number): number;
+    /**
+     * The function returns the value of a specific index in a freqMap data structure, or a default value if
+     * the index is not found.
+     * @param {number} index - The `index` parameter is a number that represents the index of a node in a
+     * freqMap data structure.
+     * @returns a number.
+     */
+    protected _getFrequency(index: number): number;
+    /**
+     * The function _updateFrequency adds a delta value to the element at the specified index in the freqMap array.
+     * @param {number} index - The index parameter is a number that represents the index of the freqMap
+     * element that needs to be updated.
+     * @param {number} delta - The `delta` parameter represents the change in value that needs to be
+     * added to the freqMap at the specified `index`.
+     */
+    protected _updateFrequency(index: number, delta: number): void;
+    /**
+     * The function checks if the given index is valid and within the range.
+     * @param {number} index - The parameter "index" is of type number and represents the index value
+     * that needs to be checked.
+     */
+    protected _checkIndex(index: number): void;
+    /**
+     * The function calculates the sum of elements in an array up to a given index using a binary indexed
+     * freqMap.
+     * @param {number} index - The `index` parameter is a number that represents the index of an element in a
+     * data structure.
+     * @returns a number.
+     */
+    protected _readSingle(index: number): number;
+    /**
+     * The function `_updateNegativeCount` updates a counter based on changes in frequency values.
+     * @param {number} freqCur - The current frequency value.
+     * @param {number} freqNew - The freqNew parameter represents the new frequency value.
+     */
+    protected _updateNegativeCount(freqCur: number, freqNew: number): void;
+    /**
+     * The `_update` function updates the values in a binary indexed freqMap starting from a given index and
+     * propagating the changes to its parent nodes.
+     * @param {number} index - The `index` parameter is a number that represents the index of the element in
+     * the data structure that needs to be updated.
+     * @param {number} delta - The `delta` parameter represents the change in value that needs to be
+     * applied to the elements in the data structure.
+     */
+    protected _update(index: number, delta: number): void;
+    /**
+     * The `_writeSingle` function updates the frequency at a specific index and triggers a callback if
+     * the frequency has changed.
+     * @param {number} index - The `index` parameter is a number that represents the index of the element
+     * being modified or accessed.
+     * @param {number} freq - The `freq` parameter represents the new frequency value that needs to be
+     * written to the specified index `index`.
+     */
+    protected _writeSingle(index: number, freq: number): void;
+    /**
+     * The `_read` function calculates the sum of values in a binary freqMap up to a given count.
+     * @param {number} count - The `count` parameter is a number that represents the number of elements
+     * to read from the freqMap.
+     * @returns the sum of the values obtained from calling the `_getFrequency` method for each index in the
+     * range from `count` to 1.
+     */
+    protected _read(count: number): number;
+    /**
+     * The function `_binarySearch` performs a binary search to find the largest number that satisfies a given
+     * condition.
+     * @param {number} sum - The sum parameter is a number that represents the target sum value.
+     * @param before - The `before` parameter is a function that takes two numbers `x` and `y` as
+     * arguments and returns a boolean value. It is used to determine if `x` is less than or equal to
+     * `y`. The purpose of this function is to compare two numbers and determine their order.
+     * @returns the value of the variable "left".
+     */
+    protected _binarySearch(sum: number, before: (x: number, y: number) => boolean): number;
 }