min-heap-typed 1.40.0 → 1.41.1

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

@@ -177,9 +177,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N, iterationType?: IterationType): boolean;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.
@@ -301,6 +304,14 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getPredecessor` returns the predecessor node of the given node `node`.
      */
     getPredecessor(node: N): N;
+    /**
+     * The function `getSuccessor` returns the next node in a binary tree given a node `x`, or `null` if
+     * `x` is the last node.
+     * @param {N} x - N - a node in a binary tree
+     * @returns The function `getSuccessor` returns a value of type `N` (the successor node), or `null`
+     * if there is no successor, or `undefined` if the input `x` is `undefined`.
+     */
+    getSuccessor(x: N): N | null | undefined;
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.

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

@@ -171,7 +171,7 @@ class BinaryTree {
             return;
         }
         const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-        const existNode = key !== undefined ? this.get(key, (node) => node.key) : undefined;
+        const existNode = key !== undefined ? this.getNode(key, (node) => node.key) : undefined;
         if (this.root) {
             if (existNode) {
                 existNode.value = value;
@@ -249,7 +249,7 @@ class BinaryTree {
             return bstDeletedResult;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
-        const curr = this.get(identifier, callback);
+        const curr = this.getNode(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
@@ -302,9 +302,9 @@ class BinaryTree {
      */
     getDepth(distNode, beginRoot = this.root) {
         if (typeof distNode === 'number')
-            distNode = this.get(distNode);
+            distNode = this.getNode(distNode);
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         let depth = 0;
         while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
             if (distNode === beginRoot) {
@@ -329,7 +329,7 @@ class BinaryTree {
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         if (!beginRoot)
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -521,13 +521,35 @@ class BinaryTree {
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found node (of type N) or null if no node is found.
      */
-    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         // TODO may support finding node by value equal
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
+    /**
+     * The function `get` returns the first node value in a binary tree that matches the given property or key.
+     * @param {BTNKey | N} identifier - The `identifier` parameter is the key or value of
+     * the node that you want to find in the binary tree. It can be either a `BTNKey` or `N`
+     * type.
+     * @param callback - The `callback` parameter is a function that is used to determine whether a node
+     * matches the desired criteria. It takes a node as input and returns a boolean value indicating
+     * whether the node matches the criteria or not. The default callback function
+     * (`((node: N) => node.key)`) is used if no callback function is
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
+     * the root node from which the search should begin.
+     * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
+     * performed when searching for a node in the binary tree. It can have one of the following values:
+     * @returns either the found value (of type V) or undefined if no node value is found.
+     */
+    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+        var _a;
+        if (identifier instanceof BinaryTreeNode)
+            callback = (node => node);
+        // TODO may support finding node by value equal
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value) !== null && _a !== void 0 ? _a : undefined;
+    }
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.
@@ -563,7 +585,7 @@ class BinaryTree {
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         if (!beginRoot)
             return beginRoot;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -686,7 +708,7 @@ class BinaryTree {
      */
     subTreeTraverse(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         const ans = [];
         if (!beginRoot)
             return ans;
@@ -813,7 +835,7 @@ class BinaryTree {
         const ans = [];
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const queue = new queue_1.Queue([beginRoot]);
-            function traverse(level) {
+            const traverse = (level) => {
                 if (queue.size === 0)
                     return;
                 const current = queue.shift();
@@ -823,7 +845,7 @@ class BinaryTree {
                 if (current.right)
                     queue.push(current.right);
                 traverse(level + 1);
-            }
+            };
             traverse(0);
         }
         else {
@@ -908,6 +930,24 @@ class BinaryTree {
             return node;
         }
     }
+    /**
+     * The function `getSuccessor` returns the next node in a binary tree given a node `x`, or `null` if
+     * `x` is the last node.
+     * @param {N} x - N - a node in a binary tree
+     * @returns The function `getSuccessor` returns a value of type `N` (the successor node), or `null`
+     * if there is no successor, or `undefined` if the input `x` is `undefined`.
+     */
+    getSuccessor(x) {
+        if (x.right) {
+            return this.getLeftMost(x.right);
+        }
+        let y = x.parent;
+        while (y && y && x === y.right) {
+            x = y;
+            y = y.parent;
+        }
+        return y;
+    }
     // --- start additional methods ---
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
@@ -1037,10 +1077,12 @@ class BinaryTree {
         }
         else {
             if (node.left) {
+                // @ts-ignore
                 yield* this[Symbol.iterator](node.left);
             }
             yield node.key;
             if (node.right) {
+                // @ts-ignore
                 yield* this[Symbol.iterator](node.right);
             }
         }

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

@@ -43,7 +43,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+     * @param {[BTNKey | N, V][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
      * `null
@@ -72,7 +72,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
      * than, the key of the leftmost node if the comparison result is greater than, and the key of the

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

@@ -126,7 +126,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+     * @param {[BTNKey | N, V][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
      * `null
@@ -223,7 +223,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
@@ -347,7 +347,7 @@ class BST extends binary_tree_1.BinaryTree {
      */
     lesserOrGreaterTraverse(callback = ((node) => node.key), lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')
-            targetNode = this.get(targetNode);
+            targetNode = this.getNode(targetNode);
         const ans = [];
         if (!targetNode)
             return ans;

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

@@ -1,11 +1,98 @@
-import { BTNKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
-import { IBinaryTree } from '../../interfaces';
-import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-    constructor(key: BTNKey, value?: V);
-    color: RBColor;
+import { RBTNColor } from '../../types';
+export declare class RBTreeNode {
+    key: number;
+    parent: RBTreeNode;
+    left: RBTreeNode;
+    right: RBTreeNode;
+    color: number;
+    constructor(key: number, color?: RBTNColor);
 }
-export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
-    constructor(options?: RBTreeOptions);
-    createNode(key: BTNKey, value?: V): N;
+export declare const SN: RBTreeNode;
+export declare class RedBlackTree {
+    constructor();
+    protected _root: RBTreeNode;
+    get root(): RBTreeNode;
+    /**
+     * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
+     * violations of the red-black tree properties.
+     * @param {number} key - The key parameter is a number that represents the value to be inserted into
+     * the RBTree.
+     * @returns The function does not explicitly return anything.
+     */
+    insert(key: number): void;
+    /**
+     * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
+     * tree.
+     * @param {RBTreeNode} node - The `node` parameter is of type `RBTreeNode` and represents the current
+     * node being processed in the delete operation.
+     * @returns The `delete` function does not return anything. It has a return type of `void`.
+     */
+    delete(key: number): void;
+    isRealNode(node: RBTreeNode): node is RBTreeNode;
+    /**
+     * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
+     * given key in a red-black tree.
+     * @param {number} key - The key parameter is a number that represents the value we are searching for
+     * in the RBTree.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that represents the starting
+     * point for the search in the binary search tree. If no value is provided for `beginRoot`, it
+     * defaults to the root of the binary search tree (`this.root`).
+     * @returns a RBTreeNode.
+     */
+    getNode(key: number, beginRoot?: RBTreeNode): RBTreeNode;
+    /**
+     * The function returns the leftmost node in a red-black tree.
+     * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode, which represents a node in
+     * a Red-Black Tree.
+     * @returns The leftmost node in the given RBTreeNode.
+     */
+    getLeftMost(node?: RBTreeNode): RBTreeNode;
+    /**
+     * The function returns the rightmost node in a red-black tree.
+     * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.
+     * @returns the rightmost node in a red-black tree.
+     */
+    getRightMost(node: RBTreeNode): RBTreeNode;
+    /**
+     * The function returns the successor of a given node in a red-black tree.
+     * @param {RBTreeNode} x - RBTreeNode - The node for which we want to find the successor.
+     * @returns the successor of the given RBTreeNode.
+     */
+    getSuccessor(x: RBTreeNode): RBTreeNode;
+    /**
+     * The function returns the predecessor of a given node in a red-black tree.
+     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * Red-Black Tree.
+     * @returns the predecessor of the given RBTreeNode 'x'.
+     */
+    getPredecessor(x: RBTreeNode): RBTreeNode;
+    /**
+     * The function performs a left rotation on a red-black tree node.
+     * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
+     */
+    protected _leftRotate(x: RBTreeNode): void;
+    /**
+     * The function performs a right rotation on a red-black tree node.
+     * @param {RBTreeNode} x - x is a RBTreeNode, which represents the node that needs to be right
+     * rotated.
+     */
+    protected _rightRotate(x: RBTreeNode): void;
+    /**
+     * The _fixDelete function is used to rebalance the Red-Black Tree after a node deletion.
+     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * red-black tree.
+     */
+    protected _fixDelete(x: RBTreeNode): void;
+    /**
+     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
+     * @param {RBTreeNode} u - The parameter "u" represents a RBTreeNode object.
+     * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
+     */
+    protected _rbTransplant(u: RBTreeNode, v: RBTreeNode): void;
+    /**
+     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
+     * @param {RBTreeNode} k - The parameter `k` is a RBTreeNode object, which represents a node in a
+     * red-black tree.
+     */
+    protected _fixInsert(k: RBTreeNode): void;
 }