data-structure-typed 0.8.6

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

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BST = exports.BSTNode = exports.CP = void 0;
+const binary_tree_1 = require("./binary-tree");
+var CP;
+(function (CP) {
+    CP[CP["lt"] = -1] = "lt";
+    CP[CP["eq"] = 0] = "eq";
+    CP[CP["gt"] = 1] = "gt";
+})(CP = exports.CP || (exports.CP = {}));
+class BSTNode extends binary_tree_1.BinaryTreeNode {
+    clone() {
+        return new BSTNode(this.id, this.val, this.count);
+    }
+}
+exports.BSTNode = BSTNode;
+class BST extends binary_tree_1.BinaryTree {
+    _compare(a, b) {
+        const compared = this._comparator(a, b);
+        if (compared > 0)
+            return CP.gt;
+        else if (compared < 0)
+            return CP.lt;
+        else
+            return CP.eq;
+    }
+    constructor(options) {
+        super(options);
+        this._comparator = (a, b) => a - b;
+        if (options !== undefined) {
+            const { comparator } = options;
+            if (comparator !== undefined) {
+                this._comparator = comparator;
+            }
+        }
+    }
+    createNode(id, val, count) {
+        return val !== null ? new BSTNode(id, val, count) : null;
+    }
+    put(id, val, count = 1) {
+        var _a;
+        let inserted = null;
+        const newNode = this.createNode(id, val, count);
+        if (this.root === null) {
+            this.root = newNode;
+            this.size++;
+            this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 1;
+            inserted = (this.root);
+        }
+        else {
+            let cur = this.root;
+            let traversing = true;
+            while (traversing) {
+                if (cur !== null && newNode !== null) {
+                    if (this._compare(cur.id, id) === CP.eq) {
+                        if (newNode) {
+                            cur.count += newNode.count;
+                            this.count += newNode.count;
+                            cur.val = newNode.val;
+                        }
+                        //Duplicates are not accepted.
+                        traversing = false;
+                        inserted = cur;
+                    }
+                    else if (this._compare(cur.id, id) === CP.gt) {
+                        // Traverse left of the node
+                        if (cur.left === undefined) {
+                            if (newNode) {
+                                newNode.parent = cur;
+                                newNode.familyPosition = binary_tree_1.FamilyPosition.left;
+                            }
+                            //Add to the left of the current node
+                            cur.left = newNode;
+                            this.size++;
+                            this.count += newNode.count;
+                            traversing = false;
+                            inserted = cur.left;
+                        }
+                        else {
+                            //Traverse the left of the current node
+                            if (cur.left)
+                                cur = cur.left;
+                        }
+                    }
+                    else if (this._compare(cur.id, id) === CP.lt) {
+                        // Traverse right of the node
+                        if (cur.right === undefined) {
+                            if (newNode) {
+                                newNode.parent = cur;
+                                newNode.familyPosition = binary_tree_1.FamilyPosition.right;
+                            }
+                            //Add to the right of the current node
+                            cur.right = newNode;
+                            this.size++;
+                            this.count += newNode.count;
+                            traversing = false;
+                            inserted = (cur.right);
+                        }
+                        else {
+                            //Traverse the left of the current node
+                            if (cur.right)
+                                cur = cur.right;
+                        }
+                    }
+                }
+                else {
+                    traversing = false;
+                }
+            }
+        }
+        return inserted;
+    }
+    get(nodeProperty, propertyName) {
+        var _a;
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    lastKey() {
+        var _a, _b, _c, _d, _e, _f;
+        if (this._compare(0, 1) === CP.lt)
+            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
+        else if (this._compare(0, 1) === CP.gt)
+            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
+        else
+            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
+    }
+    remove(id, ignoreCount) {
+        const bstDeletedResult = [];
+        if (!this.root)
+            return bstDeletedResult;
+        const curr = this.get(id);
+        if (!curr)
+            return bstDeletedResult;
+        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        let needBalanced = null, orgCurrent = curr;
+        if (curr.count > 1 && !ignoreCount) {
+            curr.count--;
+            this.count--;
+        }
+        else {
+            if (!curr.left) {
+                if (!parent) {
+                    if (curr.right !== undefined)
+                        this.root = curr.right;
+                }
+                else {
+                    switch (curr.familyPosition) {
+                        case binary_tree_1.FamilyPosition.left:
+                            parent.left = curr.right;
+                            break;
+                        case binary_tree_1.FamilyPosition.right:
+                            parent.right = curr.right;
+                            break;
+                    }
+                    needBalanced = parent;
+                }
+            }
+            else {
+                const leftSubTreeMax = curr.left ? this.getRightMost(curr.left) : null;
+                if (leftSubTreeMax) {
+                    const parentOfLeftSubTreeMax = leftSubTreeMax.parent;
+                    orgCurrent = curr.swapLocation(leftSubTreeMax);
+                    if (parentOfLeftSubTreeMax) {
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeMax)
+                            parentOfLeftSubTreeMax.right = leftSubTreeMax.left;
+                        else
+                            parentOfLeftSubTreeMax.left = leftSubTreeMax.left;
+                        needBalanced = parentOfLeftSubTreeMax;
+                    }
+                }
+            }
+            this.size--;
+            this.count -= curr.count;
+        }
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
+        return bstDeletedResult;
+    }
+    getNodes(nodeProperty, propertyName, onlyOne) {
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (!this.root)
+            return [];
+        const result = [];
+        if (this._loopType === binary_tree_1.LoopType.recursive) {
+            const _traverse = (cur) => {
+                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+                    return;
+                if (!cur.left && !cur.right)
+                    return;
+                if (propertyName === 'id') {
+                    if (this._compare(cur.id, nodeProperty) === CP.gt)
+                        cur.left && _traverse(cur.left);
+                    if (this._compare(cur.id, nodeProperty) === CP.lt)
+                        cur.right && _traverse(cur.right);
+                }
+                else {
+                    cur.left && _traverse(cur.left);
+                    cur.right && _traverse(cur.right);
+                }
+            };
+            _traverse(this.root);
+        }
+        else {
+            const queue = [this.root];
+            while (queue.length > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+                        return result;
+                    if (propertyName === 'id') {
+                        if (this._compare(cur.id, nodeProperty) === CP.gt)
+                            cur.left && queue.push(cur.left);
+                        if (this._compare(cur.id, nodeProperty) === CP.lt)
+                            cur.right && queue.push(cur.right);
+                    }
+                    else {
+                        cur.left && queue.push(cur.left);
+                        cur.right && queue.push(cur.right);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    // --- start additional functions
+    lesserSum(id, propertyName) {
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (!this.root)
+            return 0;
+        const getSumByPropertyName = (cur) => {
+            let needSum;
+            switch (propertyName) {
+                case 'id':
+                    needSum = cur.id;
+                    break;
+                case 'count':
+                    needSum = cur.count;
+                    break;
+                default:
+                    needSum = cur.id;
+                    break;
+            }
+            return needSum;
+        };
+        let sum = 0;
+        if (this._loopType === binary_tree_1.LoopType.recursive) {
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.id, id);
+                if (compared === CP.eq) {
+                    if (cur.right)
+                        sum += this.subTreeSum(cur.right, propertyName);
+                    return;
+                }
+                else if (compared === CP.lt) {
+                    if (cur.left)
+                        sum += this.subTreeSum(cur.left, propertyName);
+                    sum += getSumByPropertyName(cur);
+                    if (cur.right)
+                        _traverse(cur.right);
+                    else
+                        return;
+                }
+                else {
+                    if (cur.left)
+                        _traverse(cur.left);
+                    else
+                        return;
+                }
+            };
+            _traverse(this.root);
+        }
+        else {
+            const queue = [this.root];
+            while (queue.length > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    const compared = this._compare(cur.id, id);
+                    if (compared === CP.eq) {
+                        if (cur.right)
+                            sum += this.subTreeSum(cur.right, propertyName);
+                        return sum;
+                    }
+                    else if (compared === CP.lt) { // todo maybe a bug
+                        if (cur.left)
+                            sum += this.subTreeSum(cur.left, propertyName);
+                        sum += getSumByPropertyName(cur);
+                        if (cur.right)
+                            queue.push(cur.right);
+                        else
+                            return sum;
+                    }
+                    else {
+                        if (cur.left)
+                            queue.push(cur.left);
+                        else
+                            return sum;
+                    }
+                }
+            }
+        }
+        return sum;
+    }
+    allGreaterNodesAdd(node, delta, propertyName) {
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (!this.root)
+            return false;
+        const _sumByPropertyName = (cur) => {
+            switch (propertyName) {
+                case 'id':
+                    cur.id += delta;
+                    break;
+                case 'count':
+                    cur.count += delta;
+                    break;
+                default:
+                    cur.id += delta;
+                    break;
+            }
+        };
+        if (this._loopType === binary_tree_1.LoopType.recursive) {
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.id, node.id);
+                _sumByPropertyName(cur);
+                if (!cur.left && !cur.right)
+                    return;
+                if (cur.left && compared === CP.gt)
+                    _traverse(cur.left);
+                else if (cur.right && compared === CP.gt)
+                    _traverse(cur.right);
+            };
+            _traverse(this.root);
+            return true;
+        }
+        else {
+            const queue = [this.root];
+            while (queue.length > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    const compared = this._compare(cur.id, node.id);
+                    _sumByPropertyName(cur);
+                    if (cur.left && compared === CP.gt)
+                        queue.push(cur.left);
+                    else if (cur.right && compared === CP.gt)
+                        queue.push(cur.right);
+                }
+            }
+            return true;
+        }
+    }
+    balance() {
+        const sorted = this.DFS('in', 'node'), n = sorted.length;
+        this.clear();
+        if (sorted.length < 1)
+            return false;
+        if (this._loopType === binary_tree_1.LoopType.recursive) {
+            const buildBalanceBST = (l, r) => {
+                if (l > r)
+                    return;
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.put(midNode.id, midNode.val, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
+            };
+            buildBalanceBST(0, n - 1);
+            return true;
+        }
+        else {
+            const stack = [[0, n - 1]];
+            while (stack.length > 0) {
+                const popped = stack.pop();
+                if (popped) {
+                    const [l, r] = popped;
+                    if (l <= r) {
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.put(midNode.id, midNode.val, midNode.count);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    isAVLBalanced() {
+        var _a, _b;
+        if (!this.root)
+            return true;
+        let balanced = true;
+        if (this._loopType === binary_tree_1.LoopType.recursive) {
+            const _height = (cur) => {
+                if (!cur)
+                    return 0;
+                const leftHeight = _height(cur.left), rightHeight = _height(cur.right);
+                if (Math.abs(leftHeight - rightHeight) > 1)
+                    balanced = false;
+                return Math.max(leftHeight, rightHeight) + 1;
+            };
+            _height(this.root);
+        }
+        else {
+            const stack = [];
+            let node = this.root, last = null, depths = new Map();
+            while (stack.length > 0 || node) {
+                if (node) {
+                    stack.push(node);
+                    node = node.left;
+                }
+                else {
+                    node = stack[stack.length - 1];
+                    if (!node.right || last === node.right) {
+                        node = stack.pop();
+                        if (node) {
+                            let left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            let right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            if (Math.abs(left - right) > 1)
+                                return false;
+                            depths.set(node, 1 + Math.max(left, right));
+                            last = node;
+                            node = null;
+                        }
+                    }
+                    else
+                        node = node.right;
+                }
+            }
+        }
+        return balanced;
+    }
+}
+exports.BST = BST;

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

@@ -0,0 +1,20 @@
+"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);

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBTree = void 0;
+class RBTree {
+}
+exports.RBTree = RBTree;

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentTree = exports.SegmentTreeNode = void 0;
+class 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;
+    }
+    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;
+    }
+}
+exports.SegmentTreeNode = SegmentTreeNode;
+class SegmentTree {
+    get root() {
+        return this._root;
+    }
+    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);
+    }
+    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;
+    }
+    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;
+                // 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);
+    }
+    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);
+    }
+}
+exports.SegmentTree = SegmentTree;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMultiSet = void 0;
+const bst_1 = require("./bst");
+class TreeMultiSet extends bst_1.BST {
+    createNode(id, val, count) {
+        return new bst_1.BSTNode(id, val, count);
+    }
+    put(id, val, count) {
+        return super.put(id, val, count);
+    }
+    remove(id, isUpdateAllLeftSum) {
+        return super.remove(id, isUpdateAllLeftSum);
+    }
+}
+exports.TreeMultiSet = TreeMultiSet;

package/dist/data-structures/binary-tree/two-three-tree.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwoThreeTree = void 0;
+class TwoThreeTree {
+}
+exports.TwoThreeTree = TwoThreeTree;