min-heap-typed 1.42.3 → 1.42.5

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

@@ -7,6 +7,41 @@ const queue_1 = require("../queue");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
     constructor(key, value) {
         super(key, value);
+        this.parent = undefined;
+        this._left = undefined;
+        this._right = undefined;
+    }
+    /**
+     * Get the left child node.
+     */
+    get left() {
+        return this._left;
+    }
+    /**
+     * Set the left child node.
+     * @param {N | undefined} v - The left child node.
+     */
+    set left(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._left = v;
+    }
+    /**
+     * Get the right child node.
+     */
+    get right() {
+        return this._right;
+    }
+    /**
+     * Set the right child node.
+     * @param {N | undefined} v - The right child node.
+     */
+    set right(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._right = v;
     }
 }
 exports.BSTNode = BSTNode;
@@ -19,7 +54,9 @@ class BST extends binary_tree_1.BinaryTree {
      */
     constructor(options) {
         super(options);
+        this._root = undefined;
         this._comparator = (a, b) => a - b;
+        this._root = undefined;
         if (options !== undefined) {
             const { comparator } = options;
             if (comparator !== undefined) {
@@ -27,6 +64,12 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
     }
+    /**
+     * Get the root node of the binary tree.
+     */
+    get root() {
+        return this._root;
+    }
     /**
      * The function creates a new binary search tree node with the given key and value.
      * @param {BTNKey} key - The key parameter is the key value that will be associated with
@@ -41,27 +84,32 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The `add` function in a binary search tree class inserts a new node with a given key and value
      * into the tree.
-     * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
-     * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
+     * @param {BTNKey | N | undefined} keyOrNode - The `keyOrNode` parameter can be either a
+     * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `undefined`.
      * @param [value] - The `value` parameter is the value to be assigned to the new node being added to the
      * binary search tree.
      * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
-     * was not added or if the parameters were invalid, it returns null or undefined.
+     * was not added or if the parameters were invalid, it returns undefined or undefined.
      */
     add(keyOrNode, value) {
+        if (keyOrNode === 8) {
+            debugger;
+        }
+        if (keyOrNode === null)
+            return undefined;
         // TODO support node as a parameter
-        let inserted = null;
-        let newNode = null;
+        let inserted;
+        let newNode;
         if (keyOrNode instanceof BSTNode) {
             newNode = keyOrNode;
         }
         else if (typeof keyOrNode === 'number') {
             newNode = this.createNode(keyOrNode, value);
         }
-        else if (keyOrNode === null) {
-            newNode = null;
+        else {
+            newNode = undefined;
         }
-        if (this.root === null) {
+        if (this.root === undefined) {
             this._setRoot(newNode);
             this._size = this.size + 1;
             inserted = this.root;
@@ -70,7 +118,7 @@ class BST extends binary_tree_1.BinaryTree {
             let cur = this.root;
             let traversing = true;
             while (traversing) {
-                if (cur !== null && newNode !== null) {
+                if (cur !== undefined && newNode !== undefined) {
                     if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
                         if (newNode) {
                             cur.value = newNode.value;
@@ -129,20 +177,20 @@ class BST extends binary_tree_1.BinaryTree {
      * @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
+     * `undefined
      * @param {V[]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be used.
      * It can have two possible values:
-     * @returns The `addMany` function returns an array of `N`, `null`, or `undefined` values.
+     * @returns The `addMany` function returns an array of `N`, `undefined`, or `undefined` values.
      */
     addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
         // TODO this addMany function is inefficient, it should be optimized
         function hasNoNull(arr) {
-            return arr.indexOf(null) === -1;
+            return arr.indexOf(undefined) === -1;
         }
         if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
-            return super.addMany(keysOrNodes, data);
+            return super.addMany(keysOrNodes, data).map(n => n !== null && n !== void 0 ? n : undefined);
         }
         const inserted = [];
         const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
@@ -209,7 +257,7 @@ class BST extends binary_tree_1.BinaryTree {
      * 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
      * rightmost node otherwise.
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting point for finding the last
+     * @param {N | undefined} beginRoot - The `beginRoot` parameter is the starting point for finding the last
      * key in a binary tree. It represents the root node of the subtree from which the search for the
      * last key should begin. If no specific `beginRoot` is provided, the search will start from the root
      * of the entire binary
@@ -243,9 +291,9 @@ class BST extends binary_tree_1.BinaryTree {
      * the first node that matches the nodeProperty. If set to true, the function will return an array
      * containing only that node. If set to false (default), the function will continue the traversal and
      * return an array containing all nodes that match the node
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the traversal. It
+     * @param {N | undefined} beginRoot - The `beginRoot` parameter is the starting node for the traversal. It
      * specifies the root node of the binary tree from which the traversal should begin. If `beginRoot`
-     * is `null`, an empty array will be returned.
+     * is `undefined`, an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration used to
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
@@ -315,17 +363,18 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
      * of the following values:
-     * @param {BTNKey | N | null} targetNode - The `targetNode` parameter in the
+     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter in the
      * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
      * start. It can be either a reference to a specific node (`N`), the key of a node
-     * (`BTNKey`), or `null` to
+     * (`BTNKey`), or `undefined` to
      * @param iterationType - The `iterationType` parameter determines whether the traversal should be
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
     lesserOrGreaterTraverse(callback = this.defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+        var _a;
         if (typeof targetNode === 'number')
-            targetNode = this.getNode(targetNode);
+            targetNode = (_a = this.getNode(targetNode)) !== null && _a !== void 0 ? _a : undefined;
         const ans = [];
         if (!targetNode)
             return ans;
@@ -408,6 +457,7 @@ class BST extends binary_tree_1.BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
+                        debugger;
                         this.add(midNode.key, midNode.value);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -441,7 +491,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         else {
             const stack = [];
-            let node = this.root, last = null;
+            let node = this.root, last = undefined;
             const depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
@@ -459,7 +509,7 @@ class BST extends binary_tree_1.BinaryTree {
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
                             last = node;
-                            node = null;
+                            node = undefined;
                         }
                     }
                     else
@@ -469,6 +519,12 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return balanced;
     }
+    _setRoot(v) {
+        if (v) {
+            v.parent = undefined;
+        }
+        this._root = v;
+    }
     /**
      * The function compares two values using a comparator function and returns whether the first value
      * is greater than, less than, or equal to the second value.

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

@@ -4,4 +4,4 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './rb-tree';
-export * from './tree-multiset';
+export * from './tree-multimap';

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

@@ -20,4 +20,4 @@ __exportStar(require("./binary-indexed-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./rb-tree"), exports);
-__exportStar(require("./tree-multiset"), exports);
+__exportStar(require("./tree-multimap"), exports);

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

@@ -5,16 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { RBTNColor } from '../../types';
-export declare class RBTreeNode {
-    key: number;
-    parent: RBTreeNode;
-    left: RBTreeNode;
-    right: RBTreeNode;
-    color: number;
-    constructor(key: number, color?: RBTNColor);
+import { BinaryTreeDeletedResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
+import { BST, BSTNode } from "./bst";
+import { IBinaryTree } from "../../interfaces";
+export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
+    color: RBTNColor;
+    constructor(key: BTNKey, value?: V, color?: RBTNColor);
 }
-export declare const NIL: RBTreeNode;
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
@@ -22,95 +19,75 @@ export declare const NIL: RBTreeNode;
  * 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 {
-    constructor();
-    protected _root: RBTreeNode;
-    get root(): RBTreeNode;
+export declare class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+    constructor(options?: RBTreeOptions);
+    protected _root: N;
+    get root(): N;
     protected _size: number;
     get size(): number;
-    /**
-     * 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.
-     */
-    add(key: number): void;
-    /**
-     * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
-     * tree.
-     * @param {number} key - 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 | null | undefined): 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;
+    NIL: N;
+    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
+    createNode(key: BTNKey, value?: V, color?: RBTNColor): N;
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeletedResult<N>[];
+    isNode(node: N | undefined): node is N;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, 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;
     /**
      * 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;
+    getLeftMost(node?: N): N;
     /**
      * 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;
+    getRightMost(node: N): N;
     /**
      * 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;
+    getSuccessor(x: N): N | undefined;
     /**
      * 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;
+    getPredecessor(x: N): N;
     clear(): void;
-    print(beginRoot?: RBTreeNode): void;
+    protected _setRoot(v: N): void;
     /**
      * 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;
+    protected _leftRotate(x: N): 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;
+    protected _rightRotate(x: N): 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;
+    protected _fixDelete(x: N): 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;
+    protected _rbTransplant(u: N, v: N): 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;
+    protected _fixInsert(k: N): void;
 }