nlptoolkit-datastructure 1.0.1 → 1.0.3

package/dist/heap/Heap.d.ts

@@ -0,0 +1,14 @@
+export declare class Heap<T> {
+    private readonly array;
+    protected comparator: <T>(item1: T, item2: T) => number;
+    private count;
+    private n;
+    constructor(N: number, comparator: <T>(item1: T, item2: T) => number);
+    compare(data1: T, data2: T): number;
+    isEmpty(): boolean;
+    private swapNode;
+    protected percolateDown(no: number): void;
+    protected percolateUp(no: number): void;
+    delete(): T;
+    insert(data: T): void;
+}

package/dist/heap/Heap.js

@@ -0,0 +1,77 @@
+(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", "./HeapNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Heap = void 0;
+    const HeapNode_1 = require("./HeapNode");
+    class Heap {
+        constructor(N, comparator) {
+            this.comparator = comparator;
+            this.array = new Array();
+            this.count = 0;
+            this.n = N;
+            for (let i = 0; i < N; i++) {
+                this.array.push();
+            }
+        }
+        compare(data1, data2) {
+            return 0;
+        }
+        isEmpty() {
+            return this.count == 0;
+        }
+        swapNode(index1, index2) {
+            let tmp = this.array[index1];
+            this.array[index1] = this.array[index2];
+            this.array[index2] = tmp;
+        }
+        percolateDown(no) {
+            let left = 2 * no + 1;
+            let right = 2 * no + 2;
+            while ((left < this.count && this.compare(this.array[no].getData(), this.array[left].getData()) < 0) ||
+                (right < this.count && this.compare(this.array[no].getData(), this.array[right].getData()) < 0)) {
+                if (right >= this.count || this.compare(this.array[left].getData(), this.array[right].getData()) > 0) {
+                    this.swapNode(no, left);
+                    no = left;
+                }
+                else {
+                    this.swapNode(no, right);
+                    no = right;
+                }
+                left = 2 * no + 1;
+                right = 2 * no + 2;
+            }
+        }
+        percolateUp(no) {
+            let parent = Math.floor((no - 1) / 2);
+            while (parent >= 0 && this.compare(this.array[parent].getData(), this.array[no].getData()) < 0) {
+                this.swapNode(parent, no);
+                no = parent;
+                parent = Math.floor((no - 1) / 2);
+            }
+        }
+        delete() {
+            let tmp = this.array[0];
+            this.array[0] = this.array[this.count - 1];
+            this.percolateDown(0);
+            this.count = this.count - 1;
+            return tmp.getData();
+        }
+        insert(data) {
+            if (this.count < this.n) {
+                this.count = this.count + 1;
+            }
+            this.array[this.count - 1] = new HeapNode_1.HeapNode(data);
+            this.percolateUp(this.count - 1);
+        }
+    }
+    exports.Heap = Heap;
+});
+//# sourceMappingURL=Heap.js.map

package/dist/heap/Heap.js.map

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

package/dist/heap/HeapNode.d.ts

@@ -0,0 +1,5 @@
+export declare class HeapNode<T> {
+    data: T;
+    constructor(data: T);
+    getData(): T;
+}

package/dist/heap/HeapNode.js

@@ -0,0 +1,23 @@
+(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.HeapNode = void 0;
+    class HeapNode {
+        constructor(data) {
+            this.data = data;
+        }
+        getData() {
+            return this.data;
+        }
+    }
+    exports.HeapNode = HeapNode;
+});
+//# sourceMappingURL=HeapNode.js.map

package/dist/heap/HeapNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapNode.js","sourceRoot":"","sources":["../../source/heap/HeapNode.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,QAAQ;QAIjB,YAAY,IAAO;YACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,CAAC;QAEM,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,CAAA;QACpB,CAAC;KAEJ;IAZD,4BAYC"}

package/dist/heap/MaxHeap.d.ts

@@ -0,0 +1,5 @@
+import { Heap } from "./Heap";
+export declare class MaxHeap<T> extends Heap<T> {
+    constructor(N: number, comparator: <T>(item1: T, item2: T) => number);
+    compare(data1: T, data2: T): number;
+}

package/dist/heap/MaxHeap.js

@@ -0,0 +1,24 @@
+(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", "./Heap"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MaxHeap = void 0;
+    const Heap_1 = require("./Heap");
+    class MaxHeap extends Heap_1.Heap {
+        constructor(N, comparator) {
+            super(N, comparator);
+        }
+        compare(data1, data2) {
+            return this.comparator(data1, data2);
+        }
+    }
+    exports.MaxHeap = MaxHeap;
+});
+//# sourceMappingURL=MaxHeap.js.map

package/dist/heap/MaxHeap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaxHeap.js","sourceRoot":"","sources":["../../source/heap/MaxHeap.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,iCAA4B;IAG5B,MAAa,OAAW,SAAQ,WAAO;QAEnC,YAAY,CAAS,EAAE,UAA6C;YAChE,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;QACxB,CAAC;QAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;YACtB,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QACxC,CAAC;KAEJ;IAVD,0BAUC"}

package/dist/heap/MinHeap.d.ts

@@ -0,0 +1,5 @@
+import { Heap } from "./Heap";
+export declare class MinHeap<T> extends Heap<T> {
+    constructor(N: number, comparator: <T>(item1: T, item2: T) => number);
+    compare(data1: T, data2: T): number;
+}

package/dist/heap/MinHeap.js

@@ -0,0 +1,24 @@
+(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", "./Heap"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MinHeap = void 0;
+    const Heap_1 = require("./Heap");
+    class MinHeap extends Heap_1.Heap {
+        constructor(N, comparator) {
+            super(N, comparator);
+        }
+        compare(data1, data2) {
+            return -this.comparator(data1, data2);
+        }
+    }
+    exports.MinHeap = MinHeap;
+});
+//# sourceMappingURL=MinHeap.js.map

package/dist/heap/MinHeap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinHeap.js","sourceRoot":"","sources":["../../source/heap/MinHeap.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,iCAA4B;IAE5B,MAAa,OAAW,SAAQ,WAAO;QAEnC,YAAY,CAAS,EAAE,UAA6C;YAChE,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;QACxB,CAAC;QAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;YACtB,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QACzC,CAAC;KAEJ;IAVD,0BAUC"}

package/package.json

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

package/source/heap/Heap.ts

@@ -0,0 +1,77 @@
+import {HeapNode} from "./HeapNode";
+
+export class Heap<T> {
+
+    private readonly array: Array<HeapNode<T>>
+    protected comparator : <T>(item1: T, item2: T) => number
+    private count: number
+    private n: number
+
+    constructor(N: number, comparator: <T>(item1: T, item2: T) => number){
+        this.comparator = comparator
+        this.array = new Array<HeapNode<T>>()
+        this.count = 0
+        this.n = N
+        for (let i = 0; i < N; i++){
+            this.array.push()
+        }
+    }
+
+    compare(data1: T, data2: T): number{
+        return 0;
+    }
+
+    public isEmpty(): boolean{
+        return this.count == 0
+    }
+
+    private swapNode(index1: number, index2: number){
+        let tmp = this.array[index1]
+        this.array[index1] = this.array[index2]
+        this.array[index2] = tmp
+    }
+
+    protected percolateDown(no: number) {
+        let left = 2 * no + 1
+        let right = 2 * no + 2
+        while ((left < this.count && this.compare(this.array[no].getData(), this.array[left].getData()) < 0) ||
+        (right < this.count && this.compare(this.array[no].getData(), this.array[right].getData()) < 0)) {
+            if (right >= this.count || this.compare(this.array[left].getData(), this.array[right].getData()) > 0) {
+                this.swapNode(no, left)
+                no = left
+            } else {
+                this.swapNode(no, right)
+                no = right
+            }
+            left = 2 * no + 1
+            right = 2 * no + 2
+        }
+    }
+
+    protected percolateUp(no: number){
+        let parent = Math.floor((no - 1) / 2)
+        while (parent >= 0 && this.compare(this.array[parent].getData(), this.array[no].getData()) < 0){
+            this.swapNode(parent, no)
+            no = parent
+            parent = Math.floor((no - 1) / 2)
+        }
+    }
+
+    public delete(): T{
+        let tmp = this.array[0]
+        this.array[0] = this.array[this.count - 1]
+        this.percolateDown(0)
+        this.count = this.count - 1
+        return tmp.getData()
+    }
+
+    public insert(data: T){
+        if (this.count < this.n) {
+            this.count = this.count + 1
+        }
+        this.array[this.count - 1] = new HeapNode<T>(data)
+        this.percolateUp(this.count - 1)
+    }
+
+}
+

package/source/heap/HeapNode.ts

@@ -0,0 +1,13 @@
+export class HeapNode<T> {
+
+    data : T
+
+    constructor(data: T){
+        this.data = data
+    }
+
+    public getData(): T{
+        return this.data
+    }
+
+}

package/source/heap/MaxHeap.ts

@@ -0,0 +1,14 @@
+import {Heap} from "./Heap";
+import {HeapNode} from "./HeapNode";
+
+export class MaxHeap<T> extends Heap<T>{
+
+    constructor(N: number, comparator: <T>(item1: T, item2: T) => number){
+        super(N, comparator)
+    }
+
+    compare(data1: T, data2: T): number {
+        return this.comparator(data1, data2)
+    }
+
+}

package/source/heap/MinHeap.ts

@@ -0,0 +1,13 @@
+import {Heap} from "./Heap";
+
+export class MinHeap<T> extends Heap<T>{
+
+    constructor(N: number, comparator: <T>(item1: T, item2: T) => number){
+        super(N, comparator)
+    }
+
+    compare(data1: T, data2: T): number {
+        return -this.comparator(data1, data2)
+    }
+
+}

package/tests/HeapTest.ts

@@ -0,0 +1,40 @@
+import {MaxHeap} from "../dist/heap/MaxHeap";
+import * as assert from "assert";
+import {MinHeap} from "../dist/heap/MinHeap";
+
+describe('HeapTest', function() {
+    describe('HeapTest', function() {
+        function compare<T>(item1: T, item2: T): number {
+            if (typeof item1 == "number" && typeof item2 == "number"){
+                return item1 - item2
+            }
+            return 0
+        }
+        it('testMaxHeap', function() {
+            let maxHeap : MaxHeap<number> = new MaxHeap<number>(8, compare)
+            maxHeap.insert(4)
+            maxHeap.insert(6)
+            maxHeap.insert(2)
+            maxHeap.insert(5)
+            maxHeap.insert(3)
+            maxHeap.insert(1)
+            maxHeap.insert(7)
+            assert.equal(7, maxHeap.delete())
+            assert.equal(6, maxHeap.delete())
+            assert.equal(5, maxHeap.delete())
+        });
+        it('testMinHeap', function() {
+            let minHeap : MinHeap<number> = new MinHeap<number>(8, compare)
+            minHeap.insert(4)
+            minHeap.insert(6)
+            minHeap.insert(2)
+            minHeap.insert(5)
+            minHeap.insert(3)
+            minHeap.insert(1)
+            minHeap.insert(7)
+            assert.equal(1, minHeap.delete())
+            assert.equal(2, minHeap.delete())
+            assert.equal(3, minHeap.delete())
+        });
+    });
+});