nlptoolkit-datastructure 1.0.7 → 1.0.8

package/README.md

@@ -7,7 +7,7 @@ For Developers
 ============
 
 You can also see [Java](https://github.com/starlangsoftware/DataStructure), [Python](https://github.com/starlangsoftware/DataStructure-Py), 
-[Cython](https://github.com/starlangsoftware/DataStructure-Cy), [Swift](https://github.com/starlangsoftware/DataStructure-Swift), [C](https://github.com/starlangsoftware/DataStructure-C), 
+[Cython](https://github.com/starlangsoftware/DataStructure-Cy), [Swift](https://github.com/starlangsoftware/DataStructure-Swift), [Php](https://github.com/starlangsoftware/DataStructure-Php), [C](https://github.com/starlangsoftware/DataStructure-C), 
 [C#](https://github.com/starlangsoftware/DataStructure-CS), or [C++](https://github.com/starlangsoftware/DataStructure-CPP) repository.
 
 ## Requirements

package/dist/Queue.d.ts

@@ -3,10 +3,34 @@ export declare class Queue<T> {
     private head;
     private tail;
     private maxSize;
+    /**
+     * Constructor of the queue data structure
+     * @param maxSize Maximum size of the queue
+     */
     constructor(maxSize: number);
+    /**
+     * Adds a set of elements to the end of the queue
+     * @param items Elements to be inserted into the queue
+     */
     enqueueAll(items: Array<T>): void;
+    /**
+     * Adds an element to the end of the queue.
+     * @param item Element added to the queue.
+     */
     enqueue(item: T): void;
+    /**
+     * Removes an element from the start of the queue.
+     * @return Removed item
+     */
     dequeue(): T;
+    /**
+     * Returns head of the queue.
+     * @return Head of the queue
+     */
     peek(): T;
+    /**
+     * Checks if the queue is empty or not.
+     * @return Returns true if the queue is empty, false otherwise.
+     */
     isEmpty(): boolean;
 }

package/dist/Queue.js

@@ -11,6 +11,10 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Queue = void 0;
     class Queue {
+        /**
+         * Constructor of the queue data structure
+         * @param maxSize Maximum size of the queue
+         */
         constructor(maxSize) {
             this.list = [];
             this.head = 0;
@@ -18,23 +22,43 @@
             this.maxSize = maxSize;
             this.list = new Array(maxSize);
         }
+        /**
+         * Adds a set of elements to the end of the queue
+         * @param items Elements to be inserted into the queue
+         */
         enqueueAll(items) {
             for (let item of items) {
                 this.enqueue(item);
             }
         }
+        /**
+         * Adds an element to the end of the queue.
+         * @param item Element added to the queue.
+         */
         enqueue(item) {
             this.list[this.tail] = item;
             this.tail = (this.tail + 1) % this.maxSize;
         }
+        /**
+         * Removes an element from the start of the queue.
+         * @return Removed item
+         */
         dequeue() {
             let item = this.list[this.head];
             this.head = (this.head + 1) % this.maxSize;
             return item;
         }
+        /**
+         * Returns head of the queue.
+         * @return Head of the queue
+         */
         peek() {
             return this.list[this.head];
         }
+        /**
+         * Checks if the queue is empty or not.
+         * @return Returns true if the queue is empty, false otherwise.
+         */
         isEmpty() {
             return this.head == this.tail;
         }

package/dist/Queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"Queue.js","sourceRoot":"","sources":["../source/Queue.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,KAAK;QAOd,YAAY,OAAe;YALnB,SAAI,GAAc,EAAE,CAAA;YAMxB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;YACb,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;YACb,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;YACtB,IAAI,CAAC,IAAI,GAAG,IAAI,KAAK,CAAI,OAAO,CAAC,CAAA;QACrC,CAAC;QAEM,UAAU,CAAC,KAAe;YAC7B,KAAK,IAAI,IAAI,IAAI,KAAK,EAAC;gBACnB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;aACrB;QACL,CAAC;QAEM,OAAO,CAAC,IAAO;YAClB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;YAC3B,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAA;QAC9C,CAAC;QAEM,OAAO;YACV,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC/B,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAA;YAC1C,OAAO,IAAI,CAAA;QACf,CAAC;QAEM,IAAI;YACP,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC/B,CAAC;QAEM,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAA;QACjC,CAAC;KAEJ;IAvCD,sBAuCC"}
+{"version":3,"file":"Queue.js","sourceRoot":"","sources":["../source/Queue.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,KAAK;QAOd;;;WAGG;QACH,YAAY,OAAe;YATnB,SAAI,GAAc,EAAE,CAAA;YAUxB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;YACb,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;YACb,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;YACtB,IAAI,CAAC,IAAI,GAAG,IAAI,KAAK,CAAI,OAAO,CAAC,CAAA;QACrC,CAAC;QAED;;;WAGG;QACI,UAAU,CAAC,KAAe;YAC7B,KAAK,IAAI,IAAI,IAAI,KAAK,EAAC;gBACnB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;aACrB;QACL,CAAC;QAED;;;WAGG;QACI,OAAO,CAAC,IAAO;YAClB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;YAC3B,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAA;QAC9C,CAAC;QAED;;;WAGG;QACI,OAAO;YACV,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC/B,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAA;YAC1C,OAAO,IAAI,CAAA;QACf,CAAC;QAED;;;WAGG;QACI,IAAI;YACP,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC/B,CAAC;QAED;;;WAGG;QACI,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAA;QACjC,CAAC;KAEJ;IA/DD,sBA+DC"}

package/dist/Stack.d.ts

@@ -1,7 +1,30 @@
+/**
+ * Stack is a list data structure consisting of many elements. There are two types of operations defined for the
+ * elements of the stack: Adding an element to the stack (push) and removing an element from the stack (pop). In a
+ * stack, to be popped element is always the last pushed element. Also, when an element is pushed on to the stack, it
+ * is placed on top of the stack (at the end of the list).
+ * @param T Type of the data stored in the stack node.
+ */
 export declare class Stack<T> {
     private list;
     constructor();
+    /**
+     * When we push an element on top of the stack, we only need to increase the field top by 1 and place the new
+     * element on this new position. If the stack is full before this push operation, we can not push.
+     * @param item Item to insert.
+     */
     push(item: T): void;
+    /**
+     * When we remove an element from the stack (the function also returns that removed element), we need to be careful
+     * if the stack was empty or not. If the stack is not empty, the topmost element of the stack is returned and the
+     * field top is decreased by 1. If the stack is empty, the function will return null.
+     * @return The removed element
+     */
     pop(): T | null;
+    /**
+     * The function checks whether an array-implemented stack is empty or not. The function returns true if the stack is
+     * empty, false otherwise.
+     * @return True if the stack is empty, false otherwise.
+     */
     isEmpty(): boolean;
 }

package/dist/Stack.js

@@ -10,13 +10,31 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Stack = void 0;
+    /**
+     * Stack is a list data structure consisting of many elements. There are two types of operations defined for the
+     * elements of the stack: Adding an element to the stack (push) and removing an element from the stack (pop). In a
+     * stack, to be popped element is always the last pushed element. Also, when an element is pushed on to the stack, it
+     * is placed on top of the stack (at the end of the list).
+     * @param T Type of the data stored in the stack node.
+     */
     class Stack {
         constructor() {
             this.list = [];
         }
+        /**
+         * When we push an element on top of the stack, we only need to increase the field top by 1 and place the new
+         * element on this new position. If the stack is full before this push operation, we can not push.
+         * @param item Item to insert.
+         */
         push(item) {
             this.list.push(item);
         }
+        /**
+         * When we remove an element from the stack (the function also returns that removed element), we need to be careful
+         * if the stack was empty or not. If the stack is not empty, the topmost element of the stack is returned and the
+         * field top is decreased by 1. If the stack is empty, the function will return null.
+         * @return The removed element
+         */
         pop() {
             let item = this.list.pop();
             if (item == undefined) {
@@ -26,6 +44,11 @@
                 return item;
             }
         }
+        /**
+         * The function checks whether an array-implemented stack is empty or not. The function returns true if the stack is
+         * empty, false otherwise.
+         * @return True if the stack is empty, false otherwise.
+         */
         isEmpty() {
             return this.list.length == 0;
         }

package/dist/Stack.js.map

@@ -1 +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"}
+{"version":3,"file":"Stack.js","sourceRoot":"","sources":["../source/Stack.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,MAAa,KAAK;QAId;YAFQ,SAAI,GAAc,EAAE,CAAA;QAG5B,CAAC;QAED;;;;WAIG;QACI,IAAI,CAAC,IAAO;YACf,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAED;;;;;WAKG;QACI,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;QAED;;;;WAIG;QACI,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChC,CAAC;KAGJ;IAzCD,sBAyCC"}

package/dist/heap/Heap.d.ts

@@ -1,14 +1,67 @@
+/**
+ * <p>The heap data structure is a binary tree structure consisting of N elements. It shows the basic properties of the
+ * binary tree data structure. The heap has a root node and each node of it has at most two child nodes
+ * (left and right). The root node of the tree is shown at the top, and its branches grow not to up but to down manner.
+ * </p>
+ *
+ * <p>In a heap, if the maximum element is in the root node and all nodes are smaller than its descendants, then this heap
+ * is called max-heap, if the minimum element is in the root node and all nodes are larger than its descendants, then
+ * this heap is called min-heap.</p>
+ * @param T Type of the data stored in the heap node.
+ */
 export declare class Heap<T> {
     private readonly array;
     protected comparator: (item1: T, item2: T) => number;
     private count;
     private n;
+    /**
+     * Constructor of the heap. According to the comparator, the heap could be min or max heap.
+     * @param N Maximum number of elements in the heap.
+     * @param comparator Comparator function to compare two elements.
+     */
     constructor(N: number, comparator: (item1: T, item2: T) => number);
     compare(data1: T, data2: T): number;
+    /**
+     * Checks if the heap is empty or not.
+     * @return True if the heap is empty, false otherwise.
+     */
     isEmpty(): boolean;
+    /**
+     * Swaps two heap nodes in the heap given their indexes.
+     * @param index1 Index of the first node to swap.
+     * @param index2 Index of the second node to swap.
+     */
     private swapNode;
+    /**
+     * The function percolates down from a node of the tree to restore the max-heap property. Left or right children are
+     * checked, if one of them is larger than the current element of the heap, the iteration continues. The iteration is,
+     * determining the largest one of the node's children and switching that node's value with the current node's value.
+     * We need to check if current node's left and right children exist or not. These checks are done with for the left
+     * child and with for the right child.
+     * @param no Index of the starting node to restore the max-heap property.
+     */
     protected percolateDown(no: number): void;
+    /**
+     * The function percolates up from a node of the tree to restore the max-heap property. As long as the max-heap
+     * property is corrupted, the parent and its child switch their values. We need to pay attention that, the
+     * calculated index of the parent must be a valid number. In other words, while going upper levels,we need to see
+     * that we can not go up if we are at the root of the tree.
+     * @param no Index of the starting node to restore the max-heap property.
+     */
     protected percolateUp(no: number): void;
+    /**
+     * The function will return the first element, therefore the first element is stored in the variable, and the first
+     * element of the heap is set to the last element of the heap. After that, in order to restore the max-heap
+     * property, we percolate down the tree using the function. As a last step, the number of element in the heap is
+     * decremented by one.
+     * @return The first element
+     */
     delete(): T;
+    /**
+     * The insertion of a new element to the heap, proceeds from the leaf nodes to the root node. First the new element
+     * is added to the end of the heap, then as long as the max-heap property is corrupted, the new element switches
+     * place with its parent.
+     * @param data New element to be inserted.
+     */
     insert(data: T): void;
 }

package/dist/heap/Heap.js

@@ -11,7 +11,23 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Heap = void 0;
     const HeapNode_1 = require("./HeapNode");
+    /**
+     * <p>The heap data structure is a binary tree structure consisting of N elements. It shows the basic properties of the
+     * binary tree data structure. The heap has a root node and each node of it has at most two child nodes
+     * (left and right). The root node of the tree is shown at the top, and its branches grow not to up but to down manner.
+     * </p>
+     *
+     * <p>In a heap, if the maximum element is in the root node and all nodes are smaller than its descendants, then this heap
+     * is called max-heap, if the minimum element is in the root node and all nodes are larger than its descendants, then
+     * this heap is called min-heap.</p>
+     * @param T Type of the data stored in the heap node.
+     */
     class Heap {
+        /**
+         * Constructor of the heap. According to the comparator, the heap could be min or max heap.
+         * @param N Maximum number of elements in the heap.
+         * @param comparator Comparator function to compare two elements.
+         */
         constructor(N, comparator) {
             this.comparator = comparator;
             this.array = new Array();
@@ -24,14 +40,31 @@
         compare(data1, data2) {
             return 0;
         }
+        /**
+         * Checks if the heap is empty or not.
+         * @return True if the heap is empty, false otherwise.
+         */
         isEmpty() {
             return this.count == 0;
         }
+        /**
+         * Swaps two heap nodes in the heap given their indexes.
+         * @param index1 Index of the first node to swap.
+         * @param index2 Index of the second node to swap.
+         */
         swapNode(index1, index2) {
             let tmp = this.array[index1];
             this.array[index1] = this.array[index2];
             this.array[index2] = tmp;
         }
+        /**
+         * The function percolates down from a node of the tree to restore the max-heap property. Left or right children are
+         * checked, if one of them is larger than the current element of the heap, the iteration continues. The iteration is,
+         * determining the largest one of the node's children and switching that node's value with the current node's value.
+         * We need to check if current node's left and right children exist or not. These checks are done with for the left
+         * child and with for the right child.
+         * @param no Index of the starting node to restore the max-heap property.
+         */
         percolateDown(no) {
             let left = 2 * no + 1;
             let right = 2 * no + 2;
@@ -49,6 +82,13 @@
                 right = 2 * no + 2;
             }
         }
+        /**
+         * The function percolates up from a node of the tree to restore the max-heap property. As long as the max-heap
+         * property is corrupted, the parent and its child switch their values. We need to pay attention that, the
+         * calculated index of the parent must be a valid number. In other words, while going upper levels,we need to see
+         * that we can not go up if we are at the root of the tree.
+         * @param no Index of the starting node to restore the max-heap property.
+         */
         percolateUp(no) {
             let parent = Math.floor((no - 1) / 2);
             while (parent >= 0 && this.compare(this.array[parent].getData(), this.array[no].getData()) < 0) {
@@ -57,6 +97,13 @@
                 parent = Math.floor((no - 1) / 2);
             }
         }
+        /**
+         * The function will return the first element, therefore the first element is stored in the variable, and the first
+         * element of the heap is set to the last element of the heap. After that, in order to restore the max-heap
+         * property, we percolate down the tree using the function. As a last step, the number of element in the heap is
+         * decremented by one.
+         * @return The first element
+         */
         delete() {
             let tmp = this.array[0];
             this.array[0] = this.array[this.count - 1];
@@ -64,6 +111,12 @@
             this.count = this.count - 1;
             return tmp.getData();
         }
+        /**
+         * The insertion of a new element to the heap, proceeds from the leaf nodes to the root node. First the new element
+         * is added to the end of the heap, then as long as the max-heap property is corrupted, the new element switches
+         * place with its parent.
+         * @param data New element to be inserted.
+         */
         insert(data) {
             if (this.count < this.n) {
                 this.count = this.count + 1;

package/dist/heap/Heap.js.map

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

package/dist/heap/HeapNode.d.ts

@@ -1,5 +1,13 @@
 export declare class HeapNode<T> {
     data: T;
+    /**
+     * Constructor of HeapNode.
+     * @param data Data to be stored in the heap node.
+     */
     constructor(data: T);
+    /**
+     * Mutator of the data field
+     * @return Data
+     */
     getData(): T;
 }

package/dist/heap/HeapNode.js

@@ -11,9 +11,17 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.HeapNode = void 0;
     class HeapNode {
+        /**
+         * Constructor of HeapNode.
+         * @param data Data to be stored in the heap node.
+         */
         constructor(data) {
             this.data = data;
         }
+        /**
+         * Mutator of the data field
+         * @return Data
+         */
         getData() {
             return this.data;
         }

package/dist/heap/HeapNode.js.map

@@ -1 +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"}
+{"version":3,"file":"HeapNode.js","sourceRoot":"","sources":["../../source/heap/HeapNode.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,QAAQ;QAIjB;;;WAGG;QACH,YAAY,IAAO;YACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,CAAC;QAED;;;WAGG;QACI,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,CAAA;QACpB,CAAC;KAEJ;IApBD,4BAoBC"}

package/dist/heap/MaxHeap.js.map

@@ -1 +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,UAA0C;YAC7D,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"}
+{"version":3,"file":"MaxHeap.js","sourceRoot":"","sources":["../../source/heap/MaxHeap.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,iCAA4B;IAE5B,MAAa,OAAW,SAAQ,WAAO;QAEnC,YAAY,CAAS,EAAE,UAA0C;YAC7D,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/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,32 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+(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", "./CounterHashMap", "./LRUCache", "./Stack", "./tree/BTree", "./tree/BTreeNode", "./tree/AvlTree", "./tree/AvlTreeNode", "./tree/Tree", "./tree/TreeNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./CounterHashMap"), exports);
+    __exportStar(require("./LRUCache"), exports);
+    __exportStar(require("./Stack"), exports);
+    __exportStar(require("./tree/BTree"), exports);
+    __exportStar(require("./tree/BTreeNode"), exports);
+    __exportStar(require("./tree/AvlTree"), exports);
+    __exportStar(require("./tree/AvlTreeNode"), exports);
+    __exportStar(require("./tree/Tree"), exports);
+    __exportStar(require("./tree/TreeNode"), exports);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;IAAA,mDAAgC;IAChC,6CAA0B;IAC1B,0CAAuB;IACvB,+CAA4B;IAC5B,mDAAgC;IAChC,iDAA8B;IAC9B,qDAAkC;IAClC,8CAA2B;IAC3B,kDAA+B"}

package/dist/tree/AvlTree.d.ts

@@ -1,12 +1,93 @@
 import { Tree } from "./Tree";
 import { AvlTreeNode } from "./AvlTreeNode";
+/**
+ * <p>AVL (Adelson-Velskii and Landis) tree is a balanced binary search tree structure. The balance property is very simple
+ * and ensures the depth of the tree is in the level of O(log N).</p>
+ *
+ * <p>In AVL tree, the heights of the left and right subtrees of each node can differ by at most 1. If the heights of the
+ * left and right subtrees of a single node differ by more than 1, then that binary search tree is not an AVL tree.</p>
+ * @param T Type of the data stored in the tree node.
+ */
 export declare class AvlTree<T> extends Tree<T> {
     constructor(comparator: <T>(item1: T, item2: T) => number);
     height(d: AvlTreeNode<T>): number;
+    /**
+     * In rotate left, we move node k1 one level up, since due to the binary search tree
+     * property k2 > k1, we move node k2 one level down. The links updated are:
+     * <ul>
+     *     <li>Since k2 > B > k1, the left child of node k2 is now the old right child of k1</li>
+     *     <li>The right child of k1 is now k2 </li>
+     * </ul>
+     * Note that, the root node of the subtree is now k1. In order to modify the parent link of k2, the new root of the
+     * subtree is returned by the function.
+     * @param k2 Root of the subtree, which does not satisfy the AVL tree property.
+     * @return The new root of the subtree
+     */
     private rotateLeft;
+    /**
+     * In order to restore the AVL tree property, we move node k2 one level up, since due to the binary search tree
+     * property k2 > k1, we move node k1 one level down. The links updated are:
+     * <ul>
+     *     <li>Since k2 > B > k1, the right child of node k1 is now the old left child of k2.</li>
+     *     <li>The left child of k2 is now k1</li>
+     * </ul>
+     * Note that, the root node of the subtree is now k2. In order to modify the parent link of k1, the new root of the
+     * subtree is returned by the function.
+     * @param k1 Root of the subtree, which does not satisfy the AVL tree property.
+     * @return The new root of the subtree
+     */
     private rotateRight;
+    /**
+     * <p>In the first phase we will do single right rotation on the subtree rooted with k1. With this rotation, the left
+     * child of node k2 will be k1, whereas the right child of node k1 will be B (the old left child of node k2).</p>
+     *
+     * <p>In the second phase, we will do single left rotation on the subtree rooted with k3. With this rotation, the
+     * right child of node k2 will be k3, whereas the left child of node k3 will be C (the old right child of k2).</p>
+     *
+     * Note that, the new root node of the subtree is now k2. In order to modify the parent link of k3, the new root of
+     * the subtree is returned by the function.
+     * @param k3 Root of the subtree, which does not satisfy the AVL tree property.
+     * @return The new root of the subtree
+     */
     private doubleRotateLeft;
+    /**
+     * <p>In the first phase we will do single right rotation on the subtree rooted with k3. With this rotation, the right
+     * child of node k2 will be k3, whereas the left child of node k3 will be C (the old right child of node k2).</p>
+     *
+     * <p>In the second phase, we will do single right rotation on the subtree rooted with k1. With this rotation, the left
+     * child of node k2 will be k1, whereas the left child of node k1 will be B (the old left child of k2).</p>
+     *
+     * Note that, the new root node of the subtree is now k2. In order to modify the parent link of k1, the new root of
+     * the subtree is returned by the function.
+     * @param k1 Root of the subtree, which does not satisfy the AVL tree property.
+     * @return The new root of the subtree
+     */
     private doubleRotateRight;
+    /**
+     * <p>First we will proceed with the stages the same when we add a new node into a binary search tree. For this, we
+     * start from the root node and traverse in down manner. The current node we visit is represented with x and the
+     * previous node is represented with y. At each time we compare the value of the current node with the value of the
+     * new node. If the value of the new node is smaller than the value of the current node, the new node will be
+     * inserted into the left subtree of the current node. For this, we will continue with the left child to process. If
+     * the reverse is true, that is, if the value of the new node is larger than the value of the current node, the new
+     * node will be inserted into the right subtree of the current node. In this case, we will continue with the right
+     * child to process. At each step, we store the current node in a separate stack.</p>
+     *
+     * <p>When we insert a new node into an AVL tree, we need to change the heights of the nodes and check if the AVL tree
+     * property is satisfied or not. Only the height of the nodes, which we visit while we are finding the place for the
+     * new node, can be changed. So, what we should do is to pop those nodes from the stack one by one and change the
+     * heights of those nodes.</p>
+     *
+     * <p>Similarly, the nodes, which we visit while we are finding the place for the new node, may no longer satisfy the
+     * AVL tree property. So what we should do is to pop those nodes from the stack one by one and calculate the
+     * difference of the heights of their left and right subtrees. If the height difference is 2, the AVL tree property
+     * is not satisfied. If we added the new node into the left subtree of the left child, we need to do left single
+     * rotation, if we added into the right subtree of the left child, we need to do left double rotation, if we added
+     * into the left subtree of the right child, we need to do right double rotation, if we added into the right subtree
+     * of the right child, we need to the right single rotation. Since  the root node of the subtree will be changed
+     * after a rotation, the new child of y will be the new root node t.</p>
+     * @param node Node to be inserted.
+     */
     insert(node: AvlTreeNode<T>): void;
     insertData(item: T): void;
 }