data-structure-typed 1.21.4 → 1.32.0

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

@@ -0,0 +1,210 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class SegmentTreeNode {
+    constructor(start, end, sum, val) {
+        this._start = 0;
+        this._end = 0;
+        this._val = null;
+        this._sum = 0;
+        this._left = null;
+        this._right = null;
+        this._start = start;
+        this._end = end;
+        this._sum = sum;
+        this._val = val || null;
+    }
+    get start() {
+        return this._start;
+    }
+    set start(v) {
+        this._start = v;
+    }
+    get end() {
+        return this._end;
+    }
+    set end(v) {
+        this._end = v;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        this._val = v;
+    }
+    get sum() {
+        return this._sum;
+    }
+    set sum(v) {
+        this._sum = v;
+    }
+    get left() {
+        return this._left;
+    }
+    set left(v) {
+        this._left = v;
+    }
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        this._right = v;
+    }
+}
+export 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;
+        this._root = this.build(start, end);
+    }
+    get values() {
+        return this._values;
+    }
+    get start() {
+        return this._start;
+    }
+    get end() {
+        return this._end;
+    }
+    get root() {
+        return this._root;
+    }
+    /**
+     * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
+     * for 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 are
+     * building the segment tree.
+     * @returns a SegmentTreeNode object.
+     */
+    build(start, end) {
+        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} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+     * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
+     * cur.val = val;` and pass a value for `val` in the
+     * @returns The function does not return anything.
+     */
+    updateNode(index, sum, val) {
+        const root = this.root || null;
+        if (!root) {
+            return;
+        }
+        const dfs = (cur, index, sum, val) => {
+            if (cur.start === cur.end && cur.start === index) {
+                cur.sum = sum;
+                if (val !== undefined)
+                    cur.val = val;
+                return;
+            }
+            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            if (index <= mid) {
+                if (cur.left) {
+                    dfs(cur.left, index, sum, val);
+                }
+            }
+            else {
+                if (cur.right) {
+                    dfs(cur.right, index, sum, val);
+                }
+            }
+            if (cur.left && cur.right) {
+                cur.sum = cur.left.sum + cur.right.sum;
+            }
+        };
+        dfs(root, index, sum, val);
+    }
+    /**
+     * 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;
+        }
+        const dfs = (cur, i, j) => {
+            if (cur.start === i && cur.end === j) {
+                return cur.sum;
+            }
+            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            if (j <= mid) {
+                // TODO after no-non-null-assertion not ensure the logic
+                if (cur.left) {
+                    return dfs(cur.left, i, j);
+                }
+                else {
+                    return NaN;
+                }
+            }
+            else if (i > mid) {
+                // TODO after no-non-null-assertion not ensure the logic
+                if (cur.right) {
+                    // TODO after no-non-null-assertion not ensure the logic
+                    return dfs(cur.right, i, j);
+                }
+                else {
+                    return NaN;
+                }
+            }
+            else {
+                // TODO after no-non-null-assertion not ensure the logic
+                if (cur.left && cur.right) {
+                    return dfs(cur.left, i, mid) + dfs(cur.right, mid + 1, j);
+                }
+                else {
+                    return NaN;
+                }
+            }
+        };
+        return dfs(root, indexA, indexB);
+    }
+    _setValues(value) {
+        this._values = value;
+    }
+    _setStart(value) {
+        this._start = value;
+    }
+    _setEnd(value) {
+        this._end = value;
+    }
+    _setRoot(v) {
+        this._root = v;
+    }
+}

package/lib/data-structures/binary-tree/splay-tree.js

@@ -0,0 +1,2 @@
+export class SplayTree {
+}

package/{dist → lib}/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, DFSOrderPattern, NodeOrPropertyName } from '../../types';
+import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
 import { ITreeMultiset, ITreeMultisetNode } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<T = any, NEIGHBOR extends TreeMultisetNode<T, NEIGHBOR> = TreeMultisetNodeNested<T>> extends AVLTreeNode<T, NEIGHBOR> implements ITreeMultisetNode<T, NEIGHBOR> {
@@ -78,14 +78,16 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     _addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
-     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes.
-     * @param {BinaryTreeNodeId[] | N[]} idsOrNodes - An array of BinaryTreeNodeId objects or N objects. These objects
-     * represent the IDs or nodes of the binary tree where the values will be added.
-     * @param {N['val'][]} [data] - Optional array of values to be associated with each node being added. If provided, the
-     * length of the `data` array should be equal to the length of the `idsOrNodes` array.
+     * The `addMany` function takes an array of node IDs or nodes and adds them to the tree multiset, returning an array of
+     * the inserted nodes.
+     * @param {(BinaryTreeNodeId | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeId or BinaryTreeNode
+     * objects, or null values.
+     * @param {N['val'][]} [data] - The `data` parameter is an optional array of values (`N['val'][]`) that corresponds to
+     * the nodes being added. It is used when adding nodes using the `idOrNode` and `data` arguments in the `this.add()`
+     * method. If provided, the `data` array should
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes: (BinaryTreeNodeId | N)[], data?: N['val'][]): (N | null | undefined)[];
+    addMany(idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[], data?: N['val'][]): (N | null | undefined)[];
     /**
      * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
      * constructs a balanced binary search tree using either a recursive or iterative approach.
@@ -165,27 +167,22 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     morrisCount(pattern?: 'in' | 'pre' | 'post'): number[];
     /**
-     * The function DFSIterativeCount performs a depth-first search iteratively and returns an array of count values for
-     * each node.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter is a string that specifies the traversal order
-     * for the Depth-First Search (DFS) algorithm. It can have one of three values: 'in', 'pre', or 'post'.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
-     * specifies whether to return the nodes or the property names during the depth-first search traversal. If it is set to
-     * `'node'`, the function will return the nodes. If it is set to `'property'`, the function will return the property
-     * @returns The DFSIterativeCount method returns an array of numbers.
+     * The function DFSIterativeCount performs an iterative depth-first search and returns an array of node counts based on
+     * the specified traversal pattern.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
+     * the Depth-First Search (DFS) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
+     * @returns The DFSIterativeCount function returns an array of numbers, which represents the count property of each node
+     * in the DFS traversal.
      */
-    DFSIterativeCount(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): number[];
+    DFSIterativeCount(pattern?: 'in' | 'pre' | 'post'): number[];
     /**
      * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
-     * @param {DFSOrderPattern} [pattern] - The `pattern` parameter is an optional parameter that specifies the order in
-     * which the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
-     * @param [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is used to specify whether you want to retrieve the
-     * nodes themselves or a specific property of the nodes. If you pass `'count'` as the value for `nodeOrPropertyName`,
-     * the function will return an array of the `count` property of each node.
-     * @returns The DFSCount method returns an array of numbers representing the count property of each node in the DFS
+     * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
+     * the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
+     * @returns The DFSCount function returns an array of numbers, specifically the count property of each node in the DFS
      * traversal.
      */
-    DFSCount(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFSCount(pattern?: DFSOrderPattern): number[];
     /**
      * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
      * value than a given node.