nlptoolkit-datastructure 1.0.0 → 1.0.1

package/dist/Stack.d.ts

@@ -0,0 +1,7 @@
+export declare class Stack<T> {
+    private list;
+    constructor();
+    push(item: T): void;
+    pop(): T | null;
+    isEmpty(): boolean;
+}

package/dist/Stack.js

@@ -0,0 +1,35 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Stack = void 0;
+    class Stack {
+        constructor() {
+            this.list = [];
+        }
+        push(item) {
+            this.list.push(item);
+        }
+        pop() {
+            let item = this.list.pop();
+            if (item == undefined) {
+                return null;
+            }
+            else {
+                return item;
+            }
+        }
+        isEmpty() {
+            return this.list.length == 0;
+        }
+    }
+    exports.Stack = Stack;
+});
+//# sourceMappingURL=Stack.js.map

package/dist/Stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.js","sourceRoot":"","sources":["../source/Stack.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,KAAK;QAId;YAFQ,SAAI,GAAc,EAAE,CAAA;QAG5B,CAAC;QAEM,IAAI,CAAC,IAAO;YACf,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAEM,GAAG;YACN,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAA;YAC1B,IAAI,IAAI,IAAI,SAAS,EAAC;gBAClB,OAAO,IAAI,CAAA;aACd;iBAAM;gBACH,OAAO,IAAI,CAAA;aACd;QACL,CAAC;QAEM,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChC,CAAC;KAGJ;IAzBD,sBAyBC"}

package/dist/tree/AvlTree.d.ts

@@ -0,0 +1,12 @@
+import { Tree } from "./Tree";
+import { AvlTreeNode } from "./AvlTreeNode";
+export declare class AvlTree<T> extends Tree<T> {
+    constructor(comparator: <T>(item1: T, item2: T) => number);
+    height(d: AvlTreeNode<T>): number;
+    private rotateLeft;
+    private rotateRight;
+    private doubleRotateLeft;
+    private doubleRotateRight;
+    insert(node: AvlTreeNode<T>): void;
+    insertData(item: T): void;
+}

package/dist/tree/AvlTree.js

@@ -0,0 +1,107 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Tree", "./AvlTreeNode", "../Stack"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AvlTree = void 0;
+    const Tree_1 = require("./Tree");
+    const AvlTreeNode_1 = require("./AvlTreeNode");
+    const Stack_1 = require("../Stack");
+    class AvlTree extends Tree_1.Tree {
+        constructor(comparator) {
+            super(comparator);
+        }
+        height(d) {
+            if (d == null) {
+                return 0;
+            }
+            else {
+                return d.height;
+            }
+        }
+        rotateLeft(k2) {
+            let k1 = k2.left;
+            k2.left = k1.right;
+            k1.right = k2;
+            k2.height = Math.max(this.height(k2.left), this.height(k2.right)) + 1;
+            k1.height = Math.max(this.height(k1.left), k1.right.height) + 1;
+            return k1;
+        }
+        rotateRight(k1) {
+            let k2 = k1.right;
+            k1.right = k2.left;
+            k2.left = k1;
+            k2.height = Math.max(k2.left.height, this.height(k2.right)) + 1;
+            k1.height = Math.max(this.height(k1.left), this.height(k1.right)) + 1;
+            return k2;
+        }
+        doubleRotateLeft(k3) {
+            k3.left = this.rotateRight(k3.left);
+            return this.rotateLeft(k3);
+        }
+        doubleRotateRight(k1) {
+            k1.right = this.rotateLeft(k1.right);
+            return this.rotateRight(k1);
+        }
+        insert(node) {
+            let LEFT = 1, RIGHT = 2;
+            let y = null;
+            let x = this.root;
+            let t;
+            let dir1 = 0, dir2 = 0;
+            let c = new Stack_1.Stack();
+            while (x != null) {
+                y = x;
+                c.push(y);
+                dir1 = dir2;
+                if (this.comparator(node.data, x.data) < 0) {
+                    x = x.left;
+                    dir2 = LEFT;
+                }
+                else {
+                    x = x.right;
+                    dir2 = RIGHT;
+                }
+            }
+            this.insertChild(y, node);
+            while (!c.isEmpty()) {
+                x = c.pop();
+                if (x != null) {
+                    x.height = Math.max(this.height(x.left), this.height(x.right)) + 1;
+                    if (Math.abs(this.height(x.left) - this.height(x.right)) == 2) {
+                        if (dir1 == LEFT) {
+                            if (dir2 == LEFT) {
+                                t = this.rotateLeft(x);
+                            }
+                            else {
+                                t = this.doubleRotateLeft(x);
+                            }
+                        }
+                        else {
+                            if (dir2 == LEFT) {
+                                t = this.doubleRotateRight(x);
+                            }
+                            else {
+                                t = this.rotateRight(x);
+                            }
+                        }
+                        y = c.pop();
+                        this.insertChild(y, t);
+                        break;
+                    }
+                }
+            }
+        }
+        insertData(item) {
+            this.insert(new AvlTreeNode_1.AvlTreeNode(item));
+        }
+    }
+    exports.AvlTree = AvlTree;
+});
+//# sourceMappingURL=AvlTree.js.map

package/dist/tree/AvlTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvlTree.js","sourceRoot":"","sources":["../../source/tree/AvlTree.ts"],"names":[],"mappings":"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"}

package/dist/tree/AvlTreeNode.d.ts

@@ -0,0 +1,5 @@
+import { TreeNode } from "./TreeNode";
+export declare class AvlTreeNode<T> extends TreeNode<T> {
+    height: number;
+    constructor(data: T);
+}

package/dist/tree/AvlTreeNode.js

@@ -0,0 +1,22 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./TreeNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AvlTreeNode = void 0;
+    const TreeNode_1 = require("./TreeNode");
+    class AvlTreeNode extends TreeNode_1.TreeNode {
+        constructor(data) {
+            super(data);
+            this.height = 1;
+        }
+    }
+    exports.AvlTreeNode = AvlTreeNode;
+});
+//# sourceMappingURL=AvlTreeNode.js.map

package/dist/tree/AvlTreeNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvlTreeNode.js","sourceRoot":"","sources":["../../source/tree/AvlTreeNode.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,yCAAoC;IAEpC,MAAa,WAAe,SAAQ,mBAAW;QAI3C,YAAa,IAAO;YAChB,KAAK,CAAC,IAAI,CAAC,CAAA;YACX,IAAI,CAAC,MAAM,GAAG,CAAC,CAAA;QACnB,CAAC;KAEJ;IATD,kCASC"}

package/dist/tree/BTree.d.ts

@@ -0,0 +1,9 @@
+import { BTreeNode } from "./BTreeNode";
+export declare class BTree<T> {
+    root: BTreeNode<T> | null;
+    comparator: <T>(item1: T, item2: T) => number;
+    d: number;
+    constructor(d: number, comparator: <T>(item1: T, item2: T) => number);
+    search(value: T): BTreeNode<T> | null;
+    insertData(data: T): void;
+}

package/dist/tree/BTree.js

@@ -0,0 +1,58 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./BTreeNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BTree = void 0;
+    const BTreeNode_1 = require("./BTreeNode");
+    class BTree {
+        constructor(d, comparator) {
+            this.root = null;
+            this.comparator = comparator;
+            this.d = d;
+        }
+        search(value) {
+            let b = this.root;
+            while (b != null && !b.leaf) {
+                let child = b.position(value, this.comparator);
+                if (child < b.m && b.K[child] == value) {
+                    return b;
+                }
+                b = b.children[child];
+            }
+            if (b != null) {
+                let child = b.position(value, this.comparator);
+                if (child < b.m && b.K[child] == value) {
+                    return b;
+                }
+            }
+            return null;
+        }
+        insertData(data) {
+            if (this.root == null) {
+                this.root = new BTreeNode_1.BTreeNode(this.d, undefined, undefined, undefined);
+            }
+            if (this.root.leaf) {
+                let s = this.root.insertLeaf(data, this.comparator);
+                if (s != null) {
+                    let tmp = this.root;
+                    this.root = new BTreeNode_1.BTreeNode(this.d, tmp, s, tmp.K[this.d]);
+                }
+            }
+            else {
+                let s = this.root.insertNode(data, this.comparator, true);
+                if (s != null) {
+                    this.root = s;
+                }
+            }
+        }
+    }
+    exports.BTree = BTree;
+});
+//# sourceMappingURL=BTree.js.map

package/dist/tree/BTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BTree.js","sourceRoot":"","sources":["../../source/tree/BTree.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2CAAsC;IAEtC,MAAa,KAAK;QAMd,YAAY,CAAS,EAAE,UAA6C;YAJpE,SAAI,GAAyB,IAAI,CAAC;YAK9B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;YAC5B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;QACd,CAAC;QAEM,MAAM,CAAC,KAAQ;YAClB,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YAClB,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,EAAC;gBACxB,IAAI,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;gBAC9C,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,EAAC;oBACnC,OAAO,CAAC,CAAA;iBACX;gBACD,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;aACxB;YACD,IAAI,CAAC,IAAI,IAAI,EAAC;gBACV,IAAI,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;gBAC9C,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,EAAC;oBACnC,OAAO,CAAC,CAAA;iBACX;aACJ;YACD,OAAO,IAAI,CAAA;QACf,CAAC;QAEM,UAAU,CAAC,IAAO;YACrB,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,EAAC;gBAClB,IAAI,CAAC,IAAI,GAAG,IAAI,qBAAS,CAAI,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;aACxE;YACD,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAC;gBACf,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;gBACnD,IAAI,CAAC,IAAI,IAAI,EAAC;oBACV,IAAI,GAAG,GAAG,IAAI,CAAC,IAAI,CAAA;oBACnB,IAAI,CAAC,IAAI,GAAG,IAAI,qBAAS,CAAI,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC/D;aACJ;iBAAM;gBACH,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;gBAC1D,IAAI,CAAC,IAAI,IAAI,EAAC;oBACV,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;iBACjB;aACJ;QACL,CAAC;KAEJ;IA/CD,sBA+CC"}

package/dist/tree/BTreeNode.d.ts

@@ -0,0 +1,15 @@
+export declare class BTreeNode<T> {
+    K: Array<T>;
+    m: number;
+    d: number;
+    leaf: boolean;
+    children: Array<BTreeNode<T>>;
+    constructor(d: number, firstChild: BTreeNode<T> | undefined, secondChild: BTreeNode<T> | undefined, newK: T | undefined);
+    position(value: T, comparator: <T>(item1: T, item2: T) => number): number;
+    private insertIntoK;
+    private moveHalfOfTheKToNewNode;
+    private moveHalfOfTheChildrenToNewNode;
+    private moveHalfOfTheElementsToNewNode;
+    insertNode(value: T, comparator: <T>(item1: T, item2: T) => number, isRoot: boolean): BTreeNode<T> | null;
+    insertLeaf(value: T, comparator: <T>(item1: T, item2: T) => number): BTreeNode<T> | null;
+}

package/dist/tree/BTreeNode.js

@@ -0,0 +1,122 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BTreeNode = void 0;
+    class BTreeNode {
+        constructor(d, firstChild, secondChild, newK) {
+            this.d = d;
+            this.K = [];
+            this.children = [];
+            if (firstChild == undefined) {
+                this.m = 0;
+                this.leaf = true;
+            }
+            else {
+                this.m = 1;
+                this.leaf = false;
+                this.children[0] = firstChild;
+                if (secondChild != undefined) {
+                    this.children[1] = secondChild;
+                }
+                if (newK != undefined) {
+                    this.K[0] = newK;
+                }
+            }
+        }
+        position(value, comparator) {
+            if (this.m == 0) {
+                return 0;
+            }
+            if (comparator(value, this.K[this.m - 1]) > 0) {
+                return this.m;
+            }
+            else {
+                for (let i = 0; i < this.m; i++) {
+                    if (comparator(value, this.K[i]) <= 0) {
+                        return i;
+                    }
+                }
+            }
+            return -1;
+        }
+        insertIntoK(index, insertedK) {
+            for (let i = this.m; i > index; i--) {
+                this.K[i] = this.K[i - 1];
+            }
+            this.K[index] = insertedK;
+        }
+        moveHalfOfTheKToNewNode(newNode) {
+            for (let i = 0; i < this.d; i++) {
+                newNode.K[i] = this.K[i + this.d + 1];
+            }
+            newNode.m = this.d;
+        }
+        moveHalfOfTheChildrenToNewNode(newNode) {
+            for (let i = 0; i < this.d; i++) {
+                newNode.children[i] = this.children[i + this.d + 1];
+            }
+        }
+        moveHalfOfTheElementsToNewNode(newNode) {
+            this.moveHalfOfTheKToNewNode(newNode);
+            this.moveHalfOfTheChildrenToNewNode(newNode);
+        }
+        insertNode(value, comparator, isRoot) {
+            let s;
+            let newNode;
+            let child;
+            child = this.position(value, comparator);
+            if (!this.children[child].leaf) {
+                s = this.children[child].insertNode(value, comparator, false);
+            }
+            else {
+                s = this.children[child].insertLeaf(value, comparator);
+            }
+            if (s == null) {
+                return null;
+            }
+            this.insertIntoK(child, this.children[child].K[this.d]);
+            if (this.m < 2 * this.d) {
+                this.children[child + 1] = s;
+                this.m++;
+                return null;
+            }
+            else {
+                newNode = new BTreeNode(this.d, undefined, undefined, undefined);
+                newNode.leaf = false;
+                this.moveHalfOfTheElementsToNewNode(newNode);
+                newNode.children[this.d] = s;
+                this.m = this.d;
+                if (isRoot) {
+                    return new BTreeNode(this.d, this, newNode, this.K[this.d]);
+                }
+                else {
+                    return newNode;
+                }
+            }
+        }
+        insertLeaf(value, comparator) {
+            let child = this.position(value, comparator);
+            this.insertIntoK(child, value);
+            if (this.m < 2 * this.d) {
+                this.m++;
+                return null;
+            }
+            else {
+                let newNode = new BTreeNode(this.d, undefined, undefined, undefined);
+                this.moveHalfOfTheKToNewNode(newNode);
+                this.m = this.d;
+                return newNode;
+            }
+        }
+    }
+    exports.BTreeNode = BTreeNode;
+});
+//# sourceMappingURL=BTreeNode.js.map

package/dist/tree/BTreeNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BTreeNode.js","sourceRoot":"","sources":["../../source/tree/BTreeNode.ts"],"names":[],"mappings":"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"}

package/dist/tree/Tree.d.ts

@@ -0,0 +1,10 @@
+import { TreeNode } from "./TreeNode";
+export declare class Tree<T> {
+    protected root: TreeNode<T> | null;
+    protected comparator: <T>(item1: T, item2: T) => number;
+    constructor(comparator: <T>(item1: T, item2: T) => number);
+    search(value: T): TreeNode<T> | null;
+    protected insertChild(parent: TreeNode<T> | null, child: TreeNode<T>): void;
+    insert(node: TreeNode<T>): void;
+    insertData(data: T): void;
+}

package/dist/tree/Tree.js

@@ -0,0 +1,69 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./TreeNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Tree = void 0;
+    const TreeNode_1 = require("./TreeNode");
+    class Tree {
+        constructor(comparator) {
+            this.root = null;
+            this.comparator = comparator;
+        }
+        search(value) {
+            let d = this.root;
+            while (d != null) {
+                if (this.comparator(d.data, value) == 0) {
+                    return d;
+                }
+                else {
+                    if (this.comparator(d.data, value) > 0) {
+                        d = d.left;
+                    }
+                    else {
+                        d = d.right;
+                    }
+                }
+            }
+            return null;
+        }
+        insertChild(parent, child) {
+            if (parent == null) {
+                this.root = child;
+            }
+            else {
+                if (this.comparator(child.data, parent.data) < 0) {
+                    parent.left = child;
+                }
+                else {
+                    parent.right = child;
+                }
+            }
+        }
+        insert(node) {
+            let y = null;
+            let x = this.root;
+            while (x != null) {
+                y = x;
+                if (this.comparator(node.data, x.data) < 0) {
+                    x = x.left;
+                }
+                else {
+                    x = x.right;
+                }
+            }
+            this.insertChild(y, node);
+        }
+        insertData(data) {
+            this.insert(new TreeNode_1.TreeNode(data));
+        }
+    }
+    exports.Tree = Tree;
+});
+//# sourceMappingURL=Tree.js.map

package/dist/tree/Tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tree.js","sourceRoot":"","sources":["../../source/tree/Tree.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,yCAAoC;IAEpC,MAAa,IAAI;QAKb,YAAY,UAA6C;YAH/C,SAAI,GAAwB,IAAI,CAAA;YAItC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAChC,CAAC;QAEM,MAAM,CAAC,KAAQ;YAClB,IAAI,CAAC,GAAwB,IAAI,CAAC,IAAI,CAAA;YACtC,OAAO,CAAC,IAAI,IAAI,EAAC;gBACb,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAC;oBACpC,OAAO,CAAC,CAAA;iBACX;qBAAM;oBACH,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,EAAC;wBACnC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAA;qBACb;yBAAM;wBACH,CAAC,GAAG,CAAC,CAAC,KAAK,CAAA;qBACd;iBACJ;aACJ;YACD,OAAO,IAAI,CAAA;QACf,CAAC;QAES,WAAW,CAAC,MAA2B,EAAE,KAAkB;YACjE,IAAI,MAAM,IAAI,IAAI,EAAE;gBAChB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAA;aACpB;iBAAM;gBACH,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;oBAC9C,MAAM,CAAC,IAAI,GAAG,KAAK,CAAA;iBACtB;qBAAM;oBACH,MAAM,CAAC,KAAK,GAAG,KAAK,CAAA;iBACvB;aACJ;QACL,CAAC;QAEM,MAAM,CAAC,IAAiB;YAC3B,IAAI,CAAC,GAAwB,IAAI,CAAA;YACjC,IAAI,CAAC,GAAwB,IAAI,CAAC,IAAI,CAAC;YACvC,OAAO,CAAC,IAAI,IAAI,EAAC;gBACb,CAAC,GAAG,CAAC,CAAC;gBACN,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAC;oBACvC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;iBACd;qBAAM;oBACH,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;iBACf;aACJ;YACD,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC9B,CAAC;QAEM,UAAU,CAAC,IAAO;YACrB,IAAI,CAAC,MAAM,CAAC,IAAI,mBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QACpC,CAAC;KAEJ;IAvDD,oBAuDC"}

package/dist/tree/TreeNode.d.ts

@@ -0,0 +1,6 @@
+export declare class TreeNode<T> {
+    data: T;
+    left: TreeNode<T> | null;
+    right: TreeNode<T> | null;
+    constructor(data: T);
+}

package/dist/tree/TreeNode.js

@@ -0,0 +1,22 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TreeNode = void 0;
+    class TreeNode {
+        constructor(data) {
+            this.left = null;
+            this.right = null;
+            this.data = data;
+        }
+    }
+    exports.TreeNode = TreeNode;
+});
+//# sourceMappingURL=TreeNode.js.map

package/dist/tree/TreeNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeNode.js","sourceRoot":"","sources":["../../source/tree/TreeNode.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,QAAQ;QAMjB,YAAY,IAAO;YAHnB,SAAI,GAAwB,IAAI,CAAA;YAChC,UAAK,GAAwB,IAAI,CAAA;YAG7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,CAAC;KAEJ;IAVD,4BAUC"}

package/index.js

@@ -1,2 +1,9 @@
 export * from "./dist/CounterHashMap"
-export * from "./dist/LRUCache"
+export * from "./dist/LRUCache"
+export * from "./dist/Stack"
+export * from "./dist/tree/BTree"
+export * from "./dist/tree/BTreeNode"
+export * from "./dist/tree/AvlTree"
+export * from "./dist/tree/AvlTreeNode"
+export * from "./dist/tree/Tree"
+export * from "./dist/tree/TreeNode"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nlptoolkit-datastructure",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Simple Data Structures Library",
   "main": "index.js",
   "types": "index.js",

package/source/Stack.ts

@@ -0,0 +1,26 @@
+export class Stack<T> {
+
+    private list : Array<T> = []
+
+    constructor() {
+    }
+
+    public push(item: T){
+        this.list.push(item);
+    }
+
+    public pop(): T | null{
+        let item = this.list.pop()
+        if (item == undefined){
+            return null
+        } else {
+            return item
+        }
+    }
+
+    public isEmpty(): boolean{
+        return this.list.length == 0
+    }
+
+    
+}

package/source/tree/AvlTree.ts

@@ -0,0 +1,97 @@
+import {Tree} from "./Tree";
+import {AvlTreeNode} from "./AvlTreeNode";
+import {Stack} from "../Stack";
+
+export class AvlTree<T> extends Tree<T>{
+
+    constructor(comparator: <T>(item1: T, item2: T) => number){
+        super(comparator)
+    }
+
+    public height(d: AvlTreeNode<T>): number{
+        if (d == null){
+            return 0
+        } else {
+            return d.height
+        }
+    }
+
+    private rotateLeft(k2: AvlTreeNode<T>): AvlTreeNode<T>{
+        let k1 : AvlTreeNode<T> = <AvlTreeNode<T>> k2.left
+        k2.left = k1.right
+        k1.right = k2
+        k2.height = Math.max(this.height(<AvlTreeNode<T>> k2.left), this.height(<AvlTreeNode<T>> k2.right)) + 1
+        k1.height = Math.max(this.height(<AvlTreeNode<T>> k1.left), (<AvlTreeNode<T>> k1.right).height) + 1
+        return k1
+    }
+
+    private rotateRight(k1: AvlTreeNode<T>) : AvlTreeNode<T>{
+        let k2 : AvlTreeNode<T> = <AvlTreeNode<T>> k1.right
+        k1.right = k2.left
+        k2.left = k1
+        k2.height = Math.max((<AvlTreeNode<T>> k2.left).height, this.height(<AvlTreeNode<T>> k2.right)) + 1
+        k1.height = Math.max(this.height(<AvlTreeNode<T>> k1.left), this.height(<AvlTreeNode<T>> k1.right)) + 1
+        return k2
+    }
+
+    private doubleRotateLeft(k3: AvlTreeNode<T>): AvlTreeNode<T>{
+        k3.left = this.rotateRight(<AvlTreeNode<T>> k3.left)
+        return this.rotateLeft(k3)
+    }
+
+    private doubleRotateRight(k1: AvlTreeNode<T>): AvlTreeNode<T>{
+        k1.right = this.rotateLeft(<AvlTreeNode<T>> k1.right)
+        return this.rotateRight(k1)
+    }
+
+    public insert(node : AvlTreeNode<T>){
+        let LEFT = 1, RIGHT = 2
+        let y : AvlTreeNode<T> | null = null
+        let x : AvlTreeNode<T> | null = <AvlTreeNode<T>> this.root
+        let t : AvlTreeNode<T> | null
+        let dir1 = 0, dir2 = 0
+        let c : Stack<AvlTreeNode<T>> = new Stack<AvlTreeNode<T>>()
+        while (x != null){
+            y = x
+            c.push(y)
+            dir1 = dir2
+            if (this.comparator(node.data, x.data) < 0){
+                x = <AvlTreeNode<T>> x.left
+                dir2 = LEFT
+            } else {
+                x = <AvlTreeNode<T>> x.right
+                dir2 = RIGHT
+            }
+        }
+        this.insertChild(y, node)
+        while (!c.isEmpty()){
+            x = c.pop()
+            if (x != null){
+                x.height = Math.max(this.height(<AvlTreeNode<T>> x.left), this.height(<AvlTreeNode<T>> x.right)) + 1;
+                if (Math.abs(this.height(<AvlTreeNode<T>> x.left) - this.height(<AvlTreeNode<T>> x.right)) == 2){
+                    if (dir1 == LEFT){
+                        if (dir2 == LEFT){
+                            t = this.rotateLeft(x)
+                        } else {
+                            t = this.doubleRotateLeft(x)
+                        }
+                    } else {
+                        if (dir2 == LEFT){
+                            t = this.doubleRotateRight(x)
+                        } else {
+                            t = this.rotateRight(x);
+                        }
+                    }
+                    y = c.pop();
+                    this.insertChild(y, t);
+                    break;
+                }
+            }
+        }
+    }
+
+    public insertData( item : T){
+        this.insert(new AvlTreeNode<T>(item))
+    }
+
+}

package/source/tree/AvlTreeNode.ts

@@ -0,0 +1,12 @@
+import {TreeNode} from "./TreeNode";
+
+export class AvlTreeNode<T> extends TreeNode<T> {
+
+    height : number
+
+    constructor (data: T) {
+        super(data)
+        this.height = 1
+    }
+
+}

package/source/tree/BTree.ts

@@ -0,0 +1,50 @@
+import {BTreeNode} from "./BTreeNode";
+
+export class BTree<T> {
+
+    root : BTreeNode<T> | null = null;
+    comparator : <T>(item1: T, item2: T) => number
+    d : number
+
+    constructor(d: number, comparator: <T>(item1: T, item2: T) => number){
+        this.comparator = comparator
+        this.d = d
+    }
+
+    public search(value: T): BTreeNode<T> | null{
+        let b = this.root;
+        while (b != null && !b.leaf){
+            let child = b.position(value, this.comparator)
+            if (child < b.m && b.K[child] == value){
+                return b
+            }
+            b = b.children[child]
+        }
+        if (b != null){
+            let child = b.position(value, this.comparator)
+            if (child < b.m && b.K[child] == value){
+                return b
+            }
+        }
+        return null
+    }
+
+    public insertData(data: T){
+        if (this.root == null){
+            this.root = new BTreeNode<T>(this.d, undefined, undefined, undefined)
+        }
+        if (this.root.leaf){
+            let s = this.root.insertLeaf(data, this.comparator)
+            if (s != null){
+                let tmp = this.root
+                this.root = new BTreeNode<T>(this.d, tmp, s, tmp.K[this.d]);
+            }
+        } else {
+            let s = this.root.insertNode(data, this.comparator, true);
+            if (s != null){
+                this.root = s;
+            }
+        }
+    }
+
+}

package/source/tree/BTreeNode.ts

@@ -0,0 +1,116 @@
+export class BTreeNode<T> {
+
+    K : Array<T>;
+    m : number
+    d : number
+    leaf: boolean
+    children : Array<BTreeNode<T>>
+
+    constructor(d: number, firstChild: BTreeNode<T> | undefined, secondChild: BTreeNode<T> | undefined, newK : T | undefined) {
+        this.d = d
+        this.K = [];
+        this.children = [];
+        if (firstChild == undefined){
+            this.m = 0
+            this.leaf = true
+        } else {
+            this.m = 1
+            this.leaf = false
+            this.children[0] = firstChild;
+            if (secondChild != undefined){
+                this.children[1] = secondChild;
+            }
+            if (newK != undefined){
+                this.K[0] = newK;
+            }
+        }
+    }
+
+    position(value: T, comparator: <T>(item1: T, item2: T) => number){
+        if (this.m == 0){
+            return 0
+        }
+        if (comparator(value, this.K[this.m - 1]) > 0){
+            return this.m
+        } else {
+            for (let i = 0; i < this.m; i++){
+                if (comparator(value, this.K[i]) <= 0){
+                    return i
+                }
+            }
+        }
+        return -1
+    }
+
+    private insertIntoK(index: number, insertedK: T){
+        for (let i = this.m; i > index; i--){
+            this.K[i] = this.K[i - 1]
+        }
+        this.K[index] = insertedK
+    }
+
+    private moveHalfOfTheKToNewNode(newNode: BTreeNode<T>) {
+        for (let i = 0; i < this.d; i++) {
+            newNode.K[i] = this.K[i + this.d + 1]
+        }
+        newNode.m = this.d
+    }
+
+    private moveHalfOfTheChildrenToNewNode(newNode: BTreeNode<T>) {
+        for (let i = 0 ; i < this.d; i++){
+            newNode.children[i] = this.children[i + this.d + 1];
+        }
+    }
+
+    private moveHalfOfTheElementsToNewNode(newNode: BTreeNode<T>){
+        this.moveHalfOfTheKToNewNode(newNode);
+        this.moveHalfOfTheChildrenToNewNode(newNode);
+    }
+
+    public insertNode(value: T, comparator: <T>(item1: T, item2: T) => number, isRoot: boolean): BTreeNode<T> | null{
+        let s : BTreeNode<T> | null
+        let newNode : BTreeNode<T>
+        let child : number
+        child = this.position(value, comparator);
+        if (!this.children[child].leaf){
+            s = this.children[child].insertNode(value, comparator, false);
+        } else {
+            s = this.children[child].insertLeaf(value, comparator);
+        }
+        if (s == null){
+            return null
+        }
+        this.insertIntoK(child, this.children[child].K[this.d])
+        if (this.m < 2 * this.d){
+            this.children[child + 1] = s
+            this.m++;
+            return null
+        } else {
+            newNode = new BTreeNode<T>(this.d, undefined, undefined, undefined);
+            newNode.leaf = false
+            this.moveHalfOfTheElementsToNewNode(newNode)
+            newNode.children[this.d] = s
+            this.m = this.d
+            if (isRoot){
+                return new BTreeNode<T>(this.d, this, newNode, this.K[this.d])
+            } else {
+                return newNode
+            }
+        }
+    }
+
+    public insertLeaf(value: T, comparator: <T>(item1: T, item2: T) => number): BTreeNode<T> | null{
+        let child = this.position(value, comparator)
+        this.insertIntoK(child, value)
+        if (this.m < 2 * this.d){
+            this.m++;
+            return null
+        } else {
+            let newNode = new BTreeNode<T>(this.d, undefined, undefined, undefined);
+            this.moveHalfOfTheKToNewNode(newNode);
+            this.m = this.d;
+            return newNode;
+        }
+    }
+
+}

package/source/tree/Tree.ts

@@ -0,0 +1,58 @@
+import {TreeNode} from "./TreeNode";
+
+export class Tree<T> {
+
+    protected root : TreeNode<T> | null = null
+    protected comparator : <T>(item1: T, item2: T) => number
+
+    constructor(comparator: <T>(item1: T, item2: T) => number){
+        this.comparator = comparator
+    }
+
+    public search(value: T): TreeNode<T> | null{
+        let d : TreeNode<T> | null = this.root
+        while (d != null){
+            if (this.comparator(d.data, value) == 0){
+                return d
+            } else {
+                if (this.comparator(d.data, value) > 0){
+                    d = d.left
+                } else {
+                    d = d.right
+                }
+            }
+        }
+        return null
+    }
+
+    protected insertChild(parent : TreeNode<T> | null, child: TreeNode<T>){
+        if (parent == null) {
+            this.root = child
+        } else {
+            if (this.comparator(child.data, parent.data) < 0) {
+                parent.left = child
+            } else {
+                parent.right = child
+            }
+        }
+    }
+
+    public insert(node: TreeNode<T>){
+        let y : TreeNode<T> | null = null
+        let x : TreeNode<T> | null = this.root;
+        while (x != null){
+            y = x;
+            if (this.comparator(node.data, x.data) < 0){
+                x = x.left;
+            } else {
+                x = x.right;
+            }
+        }
+        this.insertChild(y, node);
+    }
+
+    public insertData(data: T){
+        this.insert(new TreeNode(data));
+    }
+
+}

package/source/tree/TreeNode.ts

@@ -0,0 +1,11 @@
+export class TreeNode<T> {
+
+    data : T
+    left : TreeNode<T> | null = null
+    right : TreeNode<T> | null = null
+
+    constructor(data: T){
+        this.data = data
+    }
+
+}

package/tests/CounterHashMapTest.ts

@@ -1,4 +1,4 @@
-import {CounterHashMap} from "../source/CounterHashMap";
+import {CounterHashMap} from "../dist/CounterHashMap";
 import * as assert from "assert";
 
 describe('CounterHashMapTest', function() {

package/tests/LRUCacheTest.ts

@@ -1,5 +1,5 @@
 import * as assert from "assert";
-import {LRUCache} from "../source/LRUCache";
+import {LRUCache} from "../dist/LRUCache";
 
 describe('LRUCacheTest', function() {
     describe('LRUCacheTest', function() {

package/tests/TreeTest.ts

@@ -0,0 +1,47 @@
+import * as assert from "assert";
+import {Tree} from "../dist/tree/Tree";
+import {AvlTree} from "../dist/tree/AvlTree";
+import {BTree} from "../dist/tree/BTree";
+
+describe('TreeTest', function() {
+    describe('TreeTest', function() {
+        function compare<T>(item1: T, item2: T): number {
+            if (typeof item1 == "number" && typeof item2 == "number"){
+                return item1 - item2
+            }
+            return 0
+        }
+        it('testTree', function() {
+            let tree : Tree<number> = new Tree<number>(compare);
+            tree.insertData(4);
+            tree.insertData(6);
+            tree.insertData(2);
+            tree.insertData(5);
+            tree.insertData(3);
+            tree.insertData(1);
+            tree.insertData(7);
+            assert.notEqual(null, tree.search(3));
+            assert.equal(null, tree.search(8));
+        });
+        it('testTree2', function() {
+            let tree : AvlTree<number> = new AvlTree<number>(compare);
+            for (let i = 1; i <= 31; i++){
+                tree.insertData(i);
+            }
+            for (let i = 1; i < 32; i++){
+                assert.notEqual(null, tree.search(i));
+            }
+            assert.equal(null, tree.search(32));
+        });
+        it('testTree3', function() {
+            let tree : BTree<number> = new BTree<number>(1, compare);
+            for (let i = 1; i <= 31; i++){
+                tree.insertData(i);
+            }
+            for (let i = 1; i < 32; i++){
+                assert.notEqual(null, tree.search(i));
+            }
+            assert.equal(null, tree.search(32));
+        });
+    });
+});