data-structure-typed 0.8.6

package/.idea/data-structure-typed.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/data-structure-ts.iml" filepath="$PROJECT_DIR$/.idea/data-structure-ts.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

package/README.md

@@ -0,0 +1,2 @@
+# data-structure-ts
+Hash (CoordinateSet, CoordinateMap) Heap (MaxHeap, MinHeap) Binary Tree (AVL Tree, Binary Indexed Tree, Binary Search Tree, Segment Tree, Tree Multiset) Graph (Directed Graph, Undirected Graph) Linked List (Singly Linked List, Doubly Linked List) Matrix Priority Queue (Max Priority Queue, Min Priority Queue) Queue (Queue, Dequeue) Stack Trie

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

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

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

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVLTree = exports.AVLTreeNode = void 0;
+const bst_1 = require("./bst");
+class AVLTreeNode extends bst_1.BSTNode {
+    clone() {
+        return new AVLTreeNode(this.id, this.val, this.count);
+    }
+}
+exports.AVLTreeNode = AVLTreeNode;
+class AVLTree extends bst_1.BST {
+    createNode(id, val, count) {
+        return new AVLTreeNode(id, val, count);
+    }
+    put(id, val, count) {
+        const inserted = super.put(id, val, count);
+        if (inserted)
+            this.balancePath(inserted);
+        return inserted;
+    }
+    remove(id, isUpdateAllLeftSum) {
+        const deletedResults = super.remove(id, isUpdateAllLeftSum);
+        for (const { needBalanced } of deletedResults) {
+            if (needBalanced) {
+                this.balancePath(needBalanced);
+            }
+        }
+        return deletedResults;
+    }
+    balanceFactor(node) {
+        if (!node.right) // node has no right subtree
+            return -node.height;
+        else if (!node.left) // node has no left subtree
+            return +node.height;
+        else
+            return node.right.height - node.left.height;
+    }
+    updateHeight(node) {
+        if (!node.left && !node.right) // node is a leaf
+            node.height = 0;
+        else if (!node.left) {
+            // node has no left subtree
+            const rightHeight = node.right ? node.right.height : 0;
+            node.height = 1 + rightHeight;
+        }
+        else if (!node.right) // node has no right subtree
+            node.height = 1 + node.left.height;
+        else
+            node.height = 1 + Math.max(node.right.height, node.left.height);
+    }
+    balancePath(node) {
+        const path = this.getPathToRoot(node);
+        for (let i = path.length - 1; i >= 0; i--) {
+            const A = path[i];
+            this.updateHeight(A);
+            switch (this.balanceFactor(A)) {
+                case -2:
+                    if (A && A.left) {
+                        if (this.balanceFactor(A.left) <= 0) {
+                            this.balanceLL(A); // Perform LL rotation
+                        }
+                        else {
+                            this.balanceLR(A); // Perform LR rotation
+                        }
+                    }
+                    break;
+                case +2:
+                    if (A && A.right) {
+                        if (this.balanceFactor(A.right) >= 0) {
+                            this.balanceRR(A); // Perform RR rotation
+                        }
+                        else {
+                            this.balanceRL(A); // Perform RL rotation
+                        }
+                    }
+            }
+        }
+    }
+    balanceLL(A) {
+        const parentOfA = A.parent;
+        const B = A.left; // A is left-heavy and B is left-heavy
+        A.parent = B;
+        if (B && B.right) {
+            B.right.parent = A;
+        }
+        if (B)
+            B.parent = parentOfA;
+        if (A === this.root) {
+            if (B)
+                this.root = B;
+        }
+        else {
+            if ((parentOfA === null || parentOfA === void 0 ? void 0 : parentOfA.left) === A) {
+                parentOfA.left = B;
+            }
+            else {
+                if (parentOfA)
+                    parentOfA.right = B;
+            }
+        }
+        if (B) {
+            A.left = B.right; // Make T2 the left subtree of A
+            B.right = A; // Make A the left child of B
+        }
+        this.updateHeight(A);
+        if (B)
+            this.updateHeight(B);
+    }
+    balanceLR(A) {
+        const parentOfA = A.parent;
+        const B = A.left; // A is left-heavy
+        let C = null;
+        if (B) {
+            C = B.right; // B is right-heavy
+        }
+        if (A)
+            A.parent = C;
+        if (B)
+            B.parent = C;
+        if (C) {
+            if (C.left) {
+                C.left.parent = B;
+            }
+            if (C.right) {
+                C.right.parent = A;
+            }
+            C.parent = parentOfA;
+        }
+        if (A === this.root) {
+            if (C)
+                this.root = C;
+        }
+        else {
+            if (parentOfA) {
+                if (parentOfA.left === A) {
+                    parentOfA.left = C;
+                }
+                else {
+                    parentOfA.right = C;
+                }
+            }
+        }
+        if (C) {
+            A.left = C.right; // Make T3 the left subtree of A
+            if (B)
+                B.right = C.left; // Make T2 the right subtree of B
+            C.left = B;
+            C.right = A;
+        }
+        this.updateHeight(A); // Adjust heights
+        B && this.updateHeight(B);
+        C && this.updateHeight(C);
+    }
+    balanceRR(A) {
+        const parentOfA = A.parent;
+        const B = A.right; // A is right-heavy and B is right-heavy
+        A.parent = B;
+        if (B) {
+            if (B.left) {
+                B.left.parent = A;
+            }
+            B.parent = parentOfA;
+        }
+        if (A === this.root) {
+            if (B)
+                this.root = B;
+        }
+        else {
+            if (parentOfA) {
+                if (parentOfA.left === A) {
+                    parentOfA.left = B;
+                }
+                else {
+                    parentOfA.right = B;
+                }
+            }
+        }
+        if (B) {
+            A.right = B.left; // Make T2 the right subtree of A
+            B.left = A;
+        }
+        this.updateHeight(A);
+        B && this.updateHeight(B);
+    }
+    balanceRL(A) {
+        const parentOfA = A.parent;
+        const B = A.right; // A is right-heavy
+        let C = null;
+        if (B) {
+            C = B.left; // B is left-heavy
+        }
+        A.parent = C;
+        if (B)
+            B.parent = C;
+        if (C) {
+            if (C.left) {
+                C.left.parent = A;
+            }
+            if (C.right) {
+                C.right.parent = B;
+            }
+            C.parent = parentOfA;
+        }
+        if (A === this.root) {
+            if (C)
+                this.root = C;
+        }
+        else {
+            if (parentOfA) {
+                if (parentOfA.left === A) {
+                    parentOfA.left = C;
+                }
+                else {
+                    parentOfA.right = C;
+                }
+            }
+        }
+        if (C)
+            A.right = C.left; // Make T2 the right subtree of A
+        if (B && C)
+            B.left = C.right; // Make T3 the left subtree of B
+        if (C)
+            C.left = A;
+        if (C)
+            C.right = B;
+        this.updateHeight(A); // Adjust heights
+        B && this.updateHeight(B);
+        C && this.updateHeight(C);
+    }
+}
+exports.AVLTree = AVLTree;

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryIndexedTree = void 0;
+class BinaryIndexedTree {
+    constructor(n) {
+        this._sumTree = new Array(n + 1).fill(0);
+    }
+    update(i, delta) {
+        while (i < this._sumTree.length) {
+            this._sumTree[i] += delta;
+            i += BinaryIndexedTree.lowBit(i);
+        }
+    }
+    getPrefixSum(i) {
+        let sum = 0;
+        while (i > 0) {
+            sum += this._sumTree[i];
+            i -= BinaryIndexedTree.lowBit(i);
+        }
+        return sum;
+    }
+    getRangeSum(start, end) {
+        if (!(0 <= start && start <= end && end <= this._sumTree.length))
+            throw 'Index out of bounds';
+        return this.getPrefixSum(end) - this.getPrefixSum(start);
+    }
+    static lowBit(x) {
+        return x & (-x);
+    }
+}
+exports.BinaryIndexedTree = BinaryIndexedTree;