tree-multimap-typed 1.42.5

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

@@ -0,0 +1,434 @@
+"use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedBlackTree = exports.RBTreeNode = void 0;
+const types_1 = require("../../types");
+const bst_1 = require("./bst");
+const binary_tree_1 = require("./binary-tree");
+class RBTreeNode extends bst_1.BSTNode {
+    constructor(key, value, color = types_1.RBTNColor.BLACK) {
+        super(key, value);
+        this.color = color;
+    }
+}
+exports.RBTreeNode = RBTreeNode;
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 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 extends bst_1.BST {
+    constructor(options) {
+        super(options);
+        this._size = 0;
+        this.NIL = new RBTreeNode(NaN);
+        this._root = this.NIL;
+    }
+    get root() {
+        return this._root;
+    }
+    get size() {
+        return this._size;
+    }
+    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 !== this.NIL) {
+            y = x;
+            if (x && node.key < x.key) {
+                x = x.left;
+            }
+            else {
+                x = x === null || x === void 0 ? void 0 : x.right;
+            }
+        }
+        node.parent = y;
+        if (y === undefined) {
+            this._setRoot(node);
+        }
+        else if (node.key < y.key) {
+            y.left = node;
+        }
+        else {
+            y.right = node;
+        }
+        if (node.parent === undefined) {
+            node.color = types_1.RBTNColor.BLACK;
+            this._size++;
+            return;
+        }
+        if (node.parent.parent === undefined) {
+            this._size++;
+            return;
+        }
+        this._fixInsert(node);
+        this._size++;
+    }
+    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 = this.NIL;
+            let x, y;
+            while (node !== this.NIL) {
+                if (node && callback(node) === identifier) {
+                    z = node;
+                }
+                if (node && identifier && callback(node) <= identifier) {
+                    node = node.right;
+                }
+                else {
+                    node = node === null || node === void 0 ? void 0 : node.left;
+                }
+            }
+            if (z === this.NIL) {
+                this._size--;
+                return;
+            }
+            y = z;
+            let yOriginalColor = y.color;
+            if (z.left === this.NIL) {
+                x = z.right;
+                this._rbTransplant(z, z.right);
+            }
+            else if (z.right === this.NIL) {
+                x = z.left;
+                this._rbTransplant(z, z.left);
+            }
+            else {
+                y = this.getLeftMost(z.right);
+                yOriginalColor = y.color;
+                x = y.right;
+                if (y.parent === z) {
+                    x.parent = y;
+                }
+                else {
+                    this._rbTransplant(y, y.right);
+                    y.right = z.right;
+                    y.right.parent = y;
+                }
+                this._rbTransplant(z, y);
+                y.left = z.left;
+                y.left.parent = y;
+                y.color = z.color;
+            }
+            if (yOriginalColor === types_1.RBTNColor.BLACK) {
+                this._fixDelete(x);
+            }
+            this._size--;
+        };
+        helper(this.root);
+        // TODO
+        return ans;
+    }
+    isNode(node) {
+        return node !== this.NIL && node !== undefined;
+    }
+    /**
+     * 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(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+        var _a;
+        if (identifier instanceof binary_tree_1.BinaryTreeNode)
+            callback = (node => node);
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : 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 = this.root) {
+        while (node.left !== undefined && node.left !== this.NIL) {
+            node = node.left;
+        }
+        return node;
+    }
+    /**
+     * 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) {
+        while (node.right !== undefined && node.right !== this.NIL) {
+            node = node.right;
+        }
+        return node;
+    }
+    /**
+     * 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) {
+        if (x.right !== this.NIL) {
+            return this.getLeftMost(x.right);
+        }
+        let y = x.parent;
+        while (y !== this.NIL && y !== undefined && x === y.right) {
+            x = y;
+            y = y.parent;
+        }
+        return y;
+    }
+    /**
+     * 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) {
+        if (x.left !== this.NIL) {
+            return this.getRightMost(x.left);
+        }
+        let y = x.parent;
+        while (y !== this.NIL && x === y.left) {
+            x = y;
+            y = y.parent;
+        }
+        return y;
+    }
+    clear() {
+        this._root = this.NIL;
+        this._size = 0;
+    }
+    _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) {
+        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;
+        }
+    }
+    /**
+     * 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.
+     */
+    _rightRotate(x) {
+        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;
+        }
+    }
+    /**
+     * 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.
+     */
+    _fixDelete(x) {
+        let s;
+        while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
+            if (x.parent && x === x.parent.left) {
+                s = x.parent.right;
+                if (s.color === 1) {
+                    s.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = types_1.RBTNColor.RED;
+                    this._leftRotate(x.parent);
+                    s = x.parent.right;
+                }
+                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 && 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;
+                    }
+                    if (s)
+                        s.color = x.parent.color;
+                    x.parent.color = types_1.RBTNColor.BLACK;
+                    if (s && s.right)
+                        s.right.color = types_1.RBTNColor.BLACK;
+                    this._leftRotate(x.parent);
+                    x = this.root;
+                }
+            }
+            else {
+                s = x.parent.left;
+                if (s.color === 1) {
+                    s.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = types_1.RBTNColor.RED;
+                    this._rightRotate(x.parent);
+                    s = x.parent.left;
+                }
+                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 && 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;
+                    }
+                    if (s)
+                        s.color = x.parent.color;
+                    x.parent.color = types_1.RBTNColor.BLACK;
+                    if (s && s.left)
+                        s.left.color = types_1.RBTNColor.BLACK;
+                    this._rightRotate(x.parent);
+                    x = this.root;
+                }
+            }
+        }
+        x.color = types_1.RBTNColor.BLACK;
+    }
+    /**
+     * 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.
+     */
+    _rbTransplant(u, v) {
+        if (u.parent === undefined) {
+            this._setRoot(v);
+        }
+        else if (u === u.parent.left) {
+            u.parent.left = v;
+        }
+        else {
+            u.parent.right = v;
+        }
+        v.parent = u.parent;
+    }
+    /**
+     * 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.
+     */
+    _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;
+    }
+}
+exports.RedBlackTree = RedBlackTree;

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

@@ -0,0 +1,67 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { SegmentTreeNodeVal } from '../../types';
+export declare class SegmentTreeNode {
+    start: number;
+    end: number;
+    value: SegmentTreeNodeVal | null;
+    sum: number;
+    left: SegmentTreeNode | null;
+    right: SegmentTreeNode | null;
+    constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
+}
+export declare class SegmentTree {
+    /**
+     * The constructor initializes the values, start, end, and root properties of an object.
+     * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
+     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
+     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
+     * the beginning of the array.
+     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
+     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+     */
+    constructor(values: number[], start?: number, end?: number);
+    protected _values: number[];
+    get values(): number[];
+    protected _start: number;
+    get start(): number;
+    protected _end: number;
+    get end(): number;
+    protected _root: SegmentTreeNode | null;
+    get root(): SegmentTreeNode | null;
+    /**
+     * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
+     * the sum of values to each segment.
+     * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
+     * building the segment tree.
+     * @param {number} end - The "end" parameter represents the ending index of the segment or range for which we want to
+     * build a segment tree.
+     * @returns a SegmentTreeNode object.
+     */
+    build(start: number, end: number): SegmentTreeNode;
+    /**
+     * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
+     * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
+     * updated.
+     * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
+     * the `SegmentTreeNode` at the specified `index`.
+     * @param {SegmentTreeNodeVal} [value] - The `value` parameter is an optional value that can be assigned to the `value`
+     * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
+     * cur.value = value;` and pass a value for `value` in the
+     * @returns The function does not return anything.
+     */
+    updateNode(index: number, sum: number, value?: SegmentTreeNodeVal): void;
+    /**
+     * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
+     * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
+     * @param {number} indexB - The parameter `indexB` represents the ending index of the range for which you want to
+     * calculate the sum.
+     * @returns The function `querySumByRange` returns a number.
+     */
+    querySumByRange(indexA: number, indexB: number): number;
+}

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

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentTree = exports.SegmentTreeNode = void 0;
+class SegmentTreeNode {
+    constructor(start, end, sum, value) {
+        this.start = 0;
+        this.end = 0;
+        this.value = null;
+        this.sum = 0;
+        this.left = null;
+        this.right = null;
+        this.start = start;
+        this.end = end;
+        this.sum = sum;
+        this.value = value || null;
+    }
+}
+exports.SegmentTreeNode = SegmentTreeNode;
+class SegmentTree {
+    /**
+     * The constructor initializes the values, start, end, and root properties of an object.
+     * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
+     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
+     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
+     * the beginning of the array.
+     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
+     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+     */
+    constructor(values, start, end) {
+        this._values = [];
+        this._start = 0;
+        start = start || 0;
+        end = end || values.length - 1;
+        this._values = values;
+        this._start = start;
+        this._end = end;
+        if (values.length > 0) {
+            this._root = this.build(start, end);
+        }
+        else {
+            this._root = null;
+            this._values = [];
+        }
+    }
+    get values() {
+        return this._values;
+    }
+    get start() {
+        return this._start;
+    }
+    get end() {
+        return this._end;
+    }
+    get root() {
+        return this._root;
+    }
+    /**
+     * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
+     * the sum of values to each segment.
+     * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
+     * building the segment tree.
+     * @param {number} end - The "end" parameter represents the ending index of the segment or range for which we want to
+     * build a segment tree.
+     * @returns a SegmentTreeNode object.
+     */
+    build(start, end) {
+        if (start > end) {
+            return new SegmentTreeNode(start, end, 0);
+        }
+        if (start === end)
+            return new SegmentTreeNode(start, end, this._values[start]);
+        const mid = start + Math.floor((end - start) / 2);
+        const left = this.build(start, mid);
+        const right = this.build(mid + 1, end);
+        const cur = new SegmentTreeNode(start, end, left.sum + right.sum);
+        cur.left = left;
+        cur.right = right;
+        return cur;
+    }
+    /**
+     * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
+     * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
+     * updated.
+     * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
+     * the `SegmentTreeNode` at the specified `index`.
+     * @param {SegmentTreeNodeVal} [value] - The `value` parameter is an optional value that can be assigned to the `value`
+     * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
+     * cur.value = value;` and pass a value for `value` in the
+     * @returns The function does not return anything.
+     */
+    updateNode(index, sum, value) {
+        const root = this.root || null;
+        if (!root) {
+            return;
+        }
+        const dfs = (cur, index, sum, value) => {
+            if (cur.start === cur.end && cur.start === index) {
+                cur.sum = sum;
+                if (value !== undefined)
+                    cur.value = value;
+                return;
+            }
+            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            if (index <= mid) {
+                if (cur.left) {
+                    dfs(cur.left, index, sum, value);
+                }
+            }
+            else {
+                if (cur.right) {
+                    dfs(cur.right, index, sum, value);
+                }
+            }
+            if (cur.left && cur.right) {
+                cur.sum = cur.left.sum + cur.right.sum;
+            }
+        };
+        dfs(root, index, sum, value);
+    }
+    /**
+     * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
+     * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
+     * @param {number} indexB - The parameter `indexB` represents the ending index of the range for which you want to
+     * calculate the sum.
+     * @returns The function `querySumByRange` returns a number.
+     */
+    querySumByRange(indexA, indexB) {
+        const root = this.root || null;
+        if (!root) {
+            return 0;
+        }
+        if (indexA < 0 || indexB >= this.values.length || indexA > indexB) {
+            return NaN;
+        }
+        const dfs = (cur, i, j) => {
+            if (i <= cur.start && j >= cur.end) {
+                // The range [i, j] completely covers the current node's range [cur.start, cur.end]
+                return cur.sum;
+            }
+            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            if (j <= mid) {
+                if (cur.left) {
+                    return dfs(cur.left, i, j);
+                }
+                else {
+                    return NaN;
+                }
+            }
+            else if (i > mid) {
+                if (cur.right) {
+                    return dfs(cur.right, i, j);
+                }
+                else {
+                    return NaN;
+                }
+            }
+            else {
+                // Query both left and right subtrees
+                let leftSum = 0;
+                let rightSum = 0;
+                if (cur.left) {
+                    leftSum = dfs(cur.left, i, mid);
+                }
+                if (cur.right) {
+                    rightSum = dfs(cur.right, mid + 1, j);
+                }
+                return leftSum + rightSum;
+            }
+        };
+        return dfs(root, indexA, indexB);
+    }
+}
+exports.SegmentTree = SegmentTree;