data-structure-typed 1.42.3 → 1.42.4

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

@@ -7,24 +7,18 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.NIL = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.RBTreeNode = void 0;
 const types_1 = require("../../types");
-class RBTreeNode {
-    key;
-    parent;
-    left;
-    right;
-    color = types_1.RBTNColor.BLACK;
-    constructor(key, color = types_1.RBTNColor.BLACK) {
-        this.key = key;
+const bst_1 = require("./bst");
+const binary_tree_1 = require("./binary-tree");
+class RBTreeNode extends bst_1.BSTNode {
+    color;
+    constructor(key, value, color = types_1.RBTNColor.BLACK) {
+        super(key, value);
         this.color = color;
-        this.parent = null;
-        this.left = null;
-        this.right = null;
     }
 }
 exports.RBTreeNode = RBTreeNode;
-exports.NIL = new RBTreeNode(0);
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
@@ -32,9 +26,10 @@ exports.NIL = new RBTreeNode(0);
  * 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.
  */
-class RedBlackTree {
-    constructor() {
-        this._root = exports.NIL;
+class RedBlackTree extends bst_1.BST {
+    constructor(options) {
+        super(options);
+        this._root = this.NIL;
     }
     _root;
     get root() {
@@ -44,31 +39,40 @@ class RedBlackTree {
     get size() {
         return this._size;
     }
-    /**
-     * 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) {
-        const node = new RBTreeNode(key, types_1.RBTNColor.RED);
-        node.left = exports.NIL;
-        node.right = exports.NIL;
-        let y = null;
+    NIL = new RBTreeNode(NaN);
+    add(keyOrNode, value) {
+        let node;
+        if (typeof keyOrNode === 'number') {
+            node = this.createNode(keyOrNode, value, types_1.RBTNColor.RED);
+        }
+        else if (keyOrNode instanceof RBTreeNode) {
+            node = keyOrNode;
+        }
+        else if (keyOrNode === null) {
+            return;
+        }
+        else if (keyOrNode === undefined) {
+            return;
+        }
+        else {
+            return;
+        }
+        node.left = this.NIL;
+        node.right = this.NIL;
+        let y = undefined;
         let x = this.root;
-        while (x !== exports.NIL) {
+        while (x !== this.NIL) {
             y = x;
-            if (node.key < x.key) {
+            if (x && node.key < x.key) {
                 x = x.left;
             }
             else {
-                x = x.right;
+                x = x?.right;
             }
         }
         node.parent = y;
-        if (y === null) {
-            this._root = node;
+        if (y === undefined) {
+            this._setRoot(node);
         }
         else if (node.key < y.key) {
             y.left = node;
@@ -76,51 +80,50 @@ class RedBlackTree {
         else {
             y.right = node;
         }
-        if (node.parent === null) {
+        if (node.parent === undefined) {
             node.color = types_1.RBTNColor.BLACK;
             this._size++;
             return;
         }
-        if (node.parent.parent === null) {
+        if (node.parent.parent === undefined) {
             this._size++;
             return;
         }
         this._fixInsert(node);
         this._size++;
     }
-    /**
-     * 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) {
+    createNode(key, value, color = types_1.RBTNColor.BLACK) {
+        return new RBTreeNode(key, value, color);
+    }
+    delete(identifier, callback = this.defaultOneParamCallback) {
+        const ans = [];
+        if (identifier === null)
+            return ans;
         const helper = (node) => {
-            let z = exports.NIL;
+            let z = this.NIL;
             let x, y;
-            while (node !== exports.NIL) {
-                if (node.key === key) {
+            while (node !== this.NIL) {
+                if (node && callback(node) === identifier) {
                     z = node;
                 }
-                if (node.key <= key) {
+                if (node && identifier && callback(node) <= identifier) {
                     node = node.right;
                 }
                 else {
-                    node = node.left;
+                    node = node?.left;
                 }
             }
-            if (z === exports.NIL) {
+            if (z === this.NIL) {
                 this._size--;
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === exports.NIL) {
+            if (z.left === this.NIL) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === exports.NIL) {
+            else if (z.right === this.NIL) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -147,35 +150,31 @@ class RedBlackTree {
             this._size--;
         };
         helper(this.root);
+        // TODO
+        return ans;
     }
-    isRealNode(node) {
-        return node !== exports.NIL && node !== null;
+    isNode(node) {
+        return node !== this.NIL && node !== undefined;
     }
     /**
-     * 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.
+     * The function `get` returns the first node 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
+     * (`this.defaultOneParamCallback`) 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 node (of type N) or null if no node is found.
      */
-    getNode(key, beginRoot = this.root) {
-        const dfs = (node) => {
-            if (this.isRealNode(node)) {
-                if (key === node.key) {
-                    return node;
-                }
-                if (key < node.key)
-                    return dfs(node.left);
-                return dfs(node.right);
-            }
-            else {
-                return null;
-            }
-        };
-        return dfs(beginRoot);
+    getNode(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+        if (identifier instanceof binary_tree_1.BinaryTreeNode)
+            callback = (node => node);
+        return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
      * The function returns the leftmost node in a red-black tree.
@@ -184,7 +183,7 @@ class RedBlackTree {
      * @returns The leftmost node in the given RBTreeNode.
      */
     getLeftMost(node = this.root) {
-        while (node.left !== null && node.left !== exports.NIL) {
+        while (node.left !== undefined && node.left !== this.NIL) {
             node = node.left;
         }
         return node;
@@ -195,7 +194,7 @@ class RedBlackTree {
      * @returns the rightmost node in a red-black tree.
      */
     getRightMost(node) {
-        while (node.right !== null && node.right !== exports.NIL) {
+        while (node.right !== undefined && node.right !== this.NIL) {
             node = node.right;
         }
         return node;
@@ -206,11 +205,11 @@ class RedBlackTree {
      * @returns the successor of the given RBTreeNode.
      */
     getSuccessor(x) {
-        if (x.right !== exports.NIL) {
+        if (x.right !== this.NIL) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y !== exports.NIL && y !== null && x === y.right) {
+        while (y !== this.NIL && y !== undefined && x === y.right) {
             x = y;
             y = y.parent;
         }
@@ -223,95 +222,51 @@ class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== exports.NIL) {
+        if (x.left !== this.NIL) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== exports.NIL && x === y.left) {
+        while (y !== this.NIL && x === y.left) {
             x = y;
             y = y.parent;
         }
         return y;
     }
     clear() {
-        this._root = exports.NIL;
+        this._root = this.NIL;
         this._size = 0;
     }
-    print(beginRoot = this.root) {
-        const display = (root) => {
-            const [lines, , ,] = _displayAux(root);
-            for (const line of lines) {
-                console.log(line);
-            }
-        };
-        const _displayAux = (node) => {
-            if (node === null) {
-                return [[], 0, 0, 0];
-            }
-            if (node.right === null && node.left === null) {
-                const line = `${node.key}`;
-                const width = line.length;
-                const height = 1;
-                const middle = Math.floor(width / 2);
-                return [[line], width, height, middle];
-            }
-            if (node.right === null) {
-                const [lines, n, p, x] = _displayAux(node.left);
-                const s = `${node.key}`;
-                const u = s.length;
-                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-                const shifted_lines = lines.map(line => line + ' '.repeat(u));
-                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-            }
-            if (node.left === null) {
-                const [lines, n, p, u] = _displayAux(node.right);
-                const s = `${node.key}`;
-                const x = s.length;
-                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-            }
-            const [left, n, p, x] = _displayAux(node.left);
-            const [right, m, q, y] = _displayAux(node.right);
-            const s = `${node.key}`;
-            const u = s.length;
-            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-            if (p < q) {
-                left.push(...new Array(q - p).fill(' '.repeat(n)));
-            }
-            else if (q < p) {
-                right.push(...new Array(p - q).fill(' '.repeat(m)));
-            }
-            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-        };
-        display(beginRoot);
+    _setRoot(v) {
+        if (v) {
+            v.parent = undefined;
+        }
+        this._root = v;
     }
     /**
      * The function performs a left rotation on a red-black tree node.
      * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
      */
     _leftRotate(x) {
-        const y = x.right;
-        x.right = y.left;
-        if (y.left !== exports.NIL) {
-            y.left.parent = x;
-        }
-        y.parent = x.parent;
-        if (x.parent === null) {
-            this._root = y;
-        }
-        else if (x === x.parent.left) {
-            x.parent.left = y;
-        }
-        else {
-            x.parent.right = y;
+        if (x.right) {
+            const y = x.right;
+            x.right = y.left;
+            if (y.left !== this.NIL) {
+                if (y.left)
+                    y.left.parent = x;
+            }
+            y.parent = x.parent;
+            if (x.parent === undefined) {
+                this._setRoot(y);
+            }
+            else if (x === x.parent.left) {
+                x.parent.left = y;
+            }
+            else {
+                x.parent.right = y;
+            }
+            y.left = x;
+            x.parent = y;
         }
-        y.left = x;
-        x.parent = y;
     }
     /**
      * The function performs a right rotation on a red-black tree node.
@@ -319,23 +274,26 @@ class RedBlackTree {
      * rotated.
      */
     _rightRotate(x) {
-        const y = x.left;
-        x.left = y.right;
-        if (y.right !== exports.NIL) {
-            y.right.parent = x;
-        }
-        y.parent = x.parent;
-        if (x.parent === null) {
-            this._root = y;
-        }
-        else if (x === x.parent.right) {
-            x.parent.right = y;
-        }
-        else {
-            x.parent.left = y;
+        if (x.left) {
+            const y = x.left;
+            x.left = y.right;
+            if (y.right !== this.NIL) {
+                if (y.right)
+                    y.right.parent = x;
+            }
+            y.parent = x.parent;
+            if (x.parent === undefined) {
+                this._setRoot(y);
+            }
+            else if (x === x.parent.right) {
+                x.parent.right = y;
+            }
+            else {
+                x.parent.left = y;
+            }
+            y.right = x;
+            x.parent = y;
         }
-        y.right = x;
-        x.parent = y;
     }
     /**
      * The _fixDelete function is used to rebalance the Red-Black Tree after a node deletion.
@@ -345,7 +303,7 @@ class RedBlackTree {
     _fixDelete(x) {
         let s;
         while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
-            if (x === x.parent.left) {
+            if (x.parent && x === x.parent.left) {
                 s = x.parent.right;
                 if (s.color === 1) {
                     s.color = types_1.RBTNColor.BLACK;
@@ -353,20 +311,23 @@ class RedBlackTree {
                     this._leftRotate(x.parent);
                     s = x.parent.right;
                 }
-                if (s.left !== null && s.left.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
+                if (s.left !== undefined && s.left.color === types_1.RBTNColor.BLACK && s.right && s.right.color === types_1.RBTNColor.BLACK) {
                     s.color = types_1.RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.right.color === types_1.RBTNColor.BLACK) {
-                        s.left.color = types_1.RBTNColor.BLACK;
+                    if (s.right && s.right.color === types_1.RBTNColor.BLACK) {
+                        if (s.left)
+                            s.left.color = types_1.RBTNColor.BLACK;
                         s.color = types_1.RBTNColor.RED;
                         this._rightRotate(s);
                         s = x.parent.right;
                     }
-                    s.color = x.parent.color;
+                    if (s)
+                        s.color = x.parent.color;
                     x.parent.color = types_1.RBTNColor.BLACK;
-                    s.right.color = types_1.RBTNColor.BLACK;
+                    if (s && s.right)
+                        s.right.color = types_1.RBTNColor.BLACK;
                     this._leftRotate(x.parent);
                     x = this.root;
                 }
@@ -379,20 +340,23 @@ class RedBlackTree {
                     this._rightRotate(x.parent);
                     s = x.parent.left;
                 }
-                if (s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
+                if (s && s.right && s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
                     s.color = types_1.RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.left.color === types_1.RBTNColor.BLACK) {
-                        s.right.color = types_1.RBTNColor.BLACK;
+                    if (s && s.left && s.left.color === types_1.RBTNColor.BLACK) {
+                        if (s.right)
+                            s.right.color = types_1.RBTNColor.BLACK;
                         s.color = types_1.RBTNColor.RED;
                         this._leftRotate(s);
                         s = x.parent.left;
                     }
-                    s.color = x.parent.color;
+                    if (s)
+                        s.color = x.parent.color;
                     x.parent.color = types_1.RBTNColor.BLACK;
-                    s.left.color = types_1.RBTNColor.BLACK;
+                    if (s && s.left)
+                        s.left.color = types_1.RBTNColor.BLACK;
                     this._rightRotate(x.parent);
                     x = this.root;
                 }
@@ -406,8 +370,8 @@ class RedBlackTree {
      * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
      */
     _rbTransplant(u, v) {
-        if (u.parent === null) {
-            this._root = v;
+        if (u.parent === undefined) {
+            this._setRoot(v);
         }
         else if (u === u.parent.left) {
             u.parent.left = v;
@@ -424,10 +388,10 @@ class RedBlackTree {
      */
     _fixInsert(k) {
         let u;
-        while (k.parent.color === 1) {
-            if (k.parent === k.parent.parent.right) {
+        while (k.parent && k.parent.color === 1) {
+            if (k.parent.parent && k.parent === k.parent.parent.right) {
                 u = k.parent.parent.left;
-                if (u.color === 1) {
+                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;
@@ -445,7 +409,7 @@ class RedBlackTree {
             }
             else {
                 u = k.parent.parent.right;
-                if (u.color === 1) {
+                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;

package/dist/mjs/src/data-structures/binary-tree/tree-multiset.d.ts

@@ -49,37 +49,37 @@ export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = Tr
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
-     * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+     * @param {BTNKey | N | undefined} keyOrNode - The `keyOrNode` parameter can be either a
      * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
-     * node to be added), or `null` (which represents a null node).
+     * node to be added), or `undefined` (which represents a undefined node).
      * @param [value] - The `value` parameter represents the value associated with the key that is being
      * added to the binary tree.
      * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
      * pair that will be added to the binary tree. It has a default value of 1, which means that if no
      * count is specified, the default count will be 1.
-     * @returns The function `add` returns a value of type `N | null | undefined`.
+     * @returns The function `add` returns a value of type `N | undefined | undefined`.
      */
-    add(keyOrNode: BTNKey | N | null, value?: V, count?: number): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null | undefined, value?: V, count?: number): N | undefined;
     /**
      * The function adds a new node to a binary tree if there is an available slot in the parent node.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to
-     * the tree. It can be either a node object (`N`) or `null`.
+     * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be added to
+     * the tree. It can be either a node object (`N`) or `undefined`.
      * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
      * be added as a child.
      * @returns The method `_addTo` returns either the `parent.left`, `parent.right`, or `undefined`.
      */
-    _addTo(newNode: N | null, parent: N): N | null | undefined;
+    _addTo(newNode: N | undefined, parent: N): N | undefined;
     /**
      * The `addMany` function adds multiple keys or nodes to a TreeMultiset and returns an array of the
      * inserted nodes.
-     * @param {(BTNKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
+     * @param {(BTNKey | undefined)[] | (N | undefined)[]} keysOrNodes - An array of keys or nodes to be
      * added to the multiset. Each element can be either a BTNKey or a TreeMultisetNode.
      * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond
      * to the keys or nodes being added to the multiset. It is used to associate additional data with
      * each key or node.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `N`, `undefined`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[]): (N | null | undefined)[];
+    addMany(keysOrNodes: (BTNKey | undefined)[] | (N | undefined)[], data?: V[]): (N | undefined)[];
     /**
      * The `perfectlyBalance` function in TypeScript takes a sorted array of nodes and builds a balanced
      * binary search tree using either a recursive or iterative approach.