data-structure-typed 0.9.16 → 1.3.0

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

@@ -1,3 +1,4 @@
+export * from './abstract-binary-tree';
 export * from './binary-tree';
 export * from './bst';
 export * from './binary-indexed-tree';

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

@@ -14,6 +14,7 @@ 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("./abstract-binary-tree"), exports);
 __exportStar(require("./binary-tree"), exports);
 __exportStar(require("./bst"), exports);
 __exportStar(require("./binary-indexed-tree"), exports);

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

@@ -1,2 +1,19 @@
-export declare class RBTree {
+import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
+import { IRBTree, IRBTreeNode } from '../../interfaces/rb-tree';
+import { BST, BSTNode } from './bst';
+export declare class RBTreeNode<T = any, NEIGHBOR extends RBTreeNode<T, NEIGHBOR> = RBTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IRBTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T, color?: RBColor);
+    private _color;
+    get color(): RBColor;
+    set color(value: RBColor);
+}
+export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
+    constructor(options?: RBTreeOptions);
+    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    insert(id: number, val?: N | null): void;
+    private leftRotate;
+    private rightRotate;
+    private insertFixup;
+    private deleteFixup;
+    private transplant;
 }

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

@@ -1,9 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTree = void 0;
-var RBTree = /** @class */ (function () {
-    function RBTree() {
+exports.RBTree = exports.RBTreeNode = void 0;
+const types_1 = require("../../types");
+const bst_1 = require("./bst");
+class RBTreeNode extends bst_1.BSTNode {
+    constructor(id, val, color = types_1.RBColor.RED) {
+        super(id, val);
+        this._color = color;
     }
-    return RBTree;
-}());
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+}
+exports.RBTreeNode = RBTreeNode;
+class RBTree extends bst_1.BST {
+    constructor(options) {
+        super(options);
+    }
+    createNode(id, val) {
+        return new RBTreeNode(id, val, types_1.RBColor.RED);
+    }
+    // private override _root: BinaryTreeNode<N> | null = null;
+    //
+    // override get root(): BinaryTreeNode<N> | null {
+    //     return this._root;
+    // }
+    insert(id, val) {
+    }
+    leftRotate(node) {
+    }
+    rightRotate(node) {
+    }
+    insertFixup(node) {
+    }
+    deleteFixup(node) {
+    }
+    transplant(u, v) {
+    }
+}
 exports.RBTree = RBTree;

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

@@ -1,33 +1,83 @@
-import type { SegmentTreeNodeVal } from '../types';
+/**
+ * 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 {
     constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
-    protected _start: number;
+    private _start;
     get start(): number;
     set start(v: number);
-    protected _end: number;
+    private _end;
     get end(): number;
     set end(v: number);
-    protected _val: SegmentTreeNodeVal | null;
+    private _val;
     get val(): SegmentTreeNodeVal | null;
     set val(v: SegmentTreeNodeVal | null);
-    protected _sum: number;
+    private _sum;
     get sum(): number;
     set sum(v: number);
-    protected _left: SegmentTreeNode | null;
+    private _left;
     get left(): SegmentTreeNode | null;
     set left(v: SegmentTreeNode | null);
-    protected _right: SegmentTreeNode | null;
+    private _right;
     get right(): SegmentTreeNode | null;
     set right(v: SegmentTreeNode | null);
 }
 export declare class SegmentTree {
-    protected _values: number[];
-    protected _start: number;
-    protected _end: number;
+    /**
+     * 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 _root: SegmentTreeNode | null;
+    private _values;
+    get values(): number[];
+    private _start;
+    get start(): number;
+    private _end;
+    get end(): number;
+    private _root;
     get root(): SegmentTreeNode | null;
+    /**
+     * 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: 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} [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: number, sum: number, val?: 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;
+    protected _setValues(value: number[]): void;
+    protected _setStart(value: number): void;
+    protected _setEnd(value: number): void;
+    protected _setRoot(v: SegmentTreeNode | null): void;
 }

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

@@ -1,8 +1,15 @@
 "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;
-var SegmentTreeNode = /** @class */ (function () {
-    function SegmentTreeNode(start, end, sum, val) {
+class SegmentTreeNode {
+    constructor(start, end, sum, val) {
         this._start = 0;
         this._end = 0;
         this._val = null;
@@ -14,71 +21,55 @@ var SegmentTreeNode = /** @class */ (function () {
         this._sum = sum;
         this._val = val || null;
     }
-    Object.defineProperty(SegmentTreeNode.prototype, "start", {
-        get: function () {
-            return this._start;
-        },
-        set: function (v) {
-            this._start = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTreeNode.prototype, "end", {
-        get: function () {
-            return this._end;
-        },
-        set: function (v) {
-            this._end = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTreeNode.prototype, "val", {
-        get: function () {
-            return this._val;
-        },
-        set: function (v) {
-            this._val = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTreeNode.prototype, "sum", {
-        get: function () {
-            return this._sum;
-        },
-        set: function (v) {
-            this._sum = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTreeNode.prototype, "left", {
-        get: function () {
-            return this._left;
-        },
-        set: function (v) {
-            this._left = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTreeNode.prototype, "right", {
-        get: function () {
-            return this._right;
-        },
-        set: function (v) {
-            this._right = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return SegmentTreeNode;
-}());
+    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;
+    }
+}
 exports.SegmentTreeNode = SegmentTreeNode;
-var SegmentTree = /** @class */ (function () {
-    function SegmentTree(values, start, end) {
+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;
@@ -88,37 +79,61 @@ var SegmentTree = /** @class */ (function () {
         this._end = end;
         this._root = this.build(start, end);
     }
-    Object.defineProperty(SegmentTree.prototype, "root", {
-        get: function () {
-            return this._root;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    SegmentTree.prototype.build = function (start, end) {
-        if (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]);
-        }
-        var mid = start + Math.floor((end - start) / 2);
-        var left = this.build(start, mid);
-        var right = this.build(mid + 1, end);
-        var cur = new SegmentTreeNode(start, end, left.sum + right.sum);
+        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;
-    };
-    SegmentTree.prototype.updateNode = function (index, sum, val) {
-        var root = this.root || null;
+    }
+    /**
+     * 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;
         }
-        var dfs = function (cur, index, sum, val) {
+        const dfs = (cur, index, sum, val) => {
             if (cur.start === cur.end && cur.start === index) {
                 cur.sum = sum;
                 // cur.val = val;
                 return;
             }
-            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (index <= mid) {
                 if (cur.left) {
                     dfs(cur.left, index, sum, val);
@@ -134,17 +149,24 @@ var SegmentTree = /** @class */ (function () {
             }
         };
         dfs(root, index, sum);
-    };
-    SegmentTree.prototype.querySumByRange = function (indexA, indexB) {
-        var root = this.root || null;
+    }
+    /**
+     * 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;
         }
-        var dfs = function (cur, i, j) {
+        const dfs = (cur, i, j) => {
             if (cur.start === i && cur.end === j) {
                 return cur.sum;
             }
-            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            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) {
@@ -175,7 +197,18 @@ var SegmentTree = /** @class */ (function () {
             }
         };
         return dfs(root, indexA, indexB);
-    };
-    return SegmentTree;
-}());
+    }
+    _setValues(value) {
+        this._values = value;
+    }
+    _setStart(value) {
+        this._start = value;
+    }
+    _setEnd(value) {
+        this._end = value;
+    }
+    _setRoot(v) {
+        this._root = v;
+    }
+}
 exports.SegmentTree = SegmentTree;

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

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplayTree = void 0;
-var SplayTree = /** @class */ (function () {
-    function SplayTree() {
-    }
-    return SplayTree;
-}());
+class SplayTree {
+}
 exports.SplayTree = SplayTree;