data-structure-typed 1.40.0-rc → 1.40.0

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

@@ -0,0 +1,7 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './binary-indexed-tree';
+export * from './segment-tree';
+export * from './avl-tree';
+export * from './rb-tree';
+export * from './tree-multiset';

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./bst"), exports);
+__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);

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

@@ -0,0 +1,11 @@
+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;
+}
+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;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBTree = exports.RBTreeNode = void 0;
+const types_1 = require("../../types");
+const bst_1 = require("./bst");
+class RBTreeNode extends bst_1.BSTNode {
+    constructor(key, value) {
+        super(key, value);
+        this.color = types_1.RBColor.RED;
+    }
+    color;
+}
+exports.RBTreeNode = RBTreeNode;
+class RBTree extends bst_1.BST {
+    constructor(options) {
+        super(options);
+    }
+    createNode(key, value) {
+        return new RBTreeNode(key, value);
+    }
+}
+exports.RBTree = RBTree;

package/dist/mjs/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/mjs/data-structures/binary-tree/segment-tree.js

@@ -0,0 +1,182 @@
+"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 {
+    start = 0;
+    end = 0;
+    value = null;
+    sum = 0;
+    left = null;
+    right = null;
+    constructor(start, end, sum, value) {
+        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) {
+        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 = [];
+        }
+    }
+    _values = [];
+    get values() {
+        return this._values;
+    }
+    _start = 0;
+    get start() {
+        return this._start;
+    }
+    _end;
+    get end() {
+        return this._end;
+    }
+    _root;
+    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;

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

@@ -0,0 +1,126 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { BTNKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
+import { BinaryTreeDeletedResult, BTNCallback, IterationType } from '../../types';
+import { IBinaryTree } from '../../interfaces';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, N> {
+    count: number;
+    /**
+     * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
+     * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+     * of the binary tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
+     * tree node. If no value is provided, it will be `undefined`.
+     * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
+     * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
+     * parameter when creating a new instance of the `BinaryTreeNode` class.
+     */
+    constructor(key: BTNKey, value?: V, count?: number);
+}
+/**
+ * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ */
+export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>> extends AVLTree<V, N> implements IBinaryTree<V, N> {
+    /**
+     * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
+     * merge duplicated values.
+     * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the
+     * TreeMultiset.
+     */
+    constructor(options?: TreeMultisetOptions);
+    private _count;
+    get count(): number;
+    /**
+     * The function creates a new BSTNode with the given key, value, and count.
+     * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+     * distinguish one node from another in the tree.
+     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
+     * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
+     * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
+     * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
+     */
+    createNode(key: BTNKey, value?: V, count?: number): N;
+    /**
+     * 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
+     * `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).
+     * @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`.
+     */
+    add(keyOrNode: BTNKey | N | null, value?: V, count?: number): N | null | 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} 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;
+    /**
+     * 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
+     * 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.
+     */
+    addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[]): (N | null | 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.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building a balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType?: IterationType): boolean;
+    /**
+     * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
+     * node along with the parent node that needs to be balanced.
+     * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+     * `BTNKey` or a generic type `N`. It represents the property of the node that we are
+     * searching for. It can be a specific key value or any other property of the node.
+     * @param callback - The `callback` parameter is a function that takes a node as input and returns a
+     * value. This value is compared with the `identifier` parameter to determine if the node should be
+     * included in the result. The `callback` parameter has a default value of
+     * `((node: N) => node.key)`
+     * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
+     * being deleted. If set to true, the count of the node will not be considered and the node will be
+     * deleted regardless of its count. If set to false (default), the count of the node will be
+     * decremented by 1 and
+     * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     */
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    /**
+     * The clear() function clears the contents of a data structure and sets the count to zero.
+     */
+    clear(): void;
+    /**
+     * The function swaps the values of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from `srcNode` will be swapped into.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
+    /**
+     * The function sets the value of the "_count" property.
+     * @param {number} v - number
+     */
+    protected _setCount(v: number): void;
+}