heap-typed 1.38.0 → 1.38.2

package/dist/data-structures/heap/heap.js

@@ -12,6 +12,32 @@ class Heap {
         this.nodes = [];
         this.comparator = comparator;
     }
+    /**
+     * Get the size (number of elements) of the heap.
+     */
+    get size() {
+        return this.nodes.length;
+    }
+    /**
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or undefined if the heap is empty.
+     */
+    get leaf() {
+        var _a;
+        return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : undefined;
+    }
+    /**
+     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * @param nodes
+     * @param comparator - Comparison function.
+     * @returns A new Heap instance.
+     */
+    static heapify(nodes, comparator) {
+        const binaryHeap = new Heap(comparator);
+        binaryHeap.nodes = [...nodes];
+        binaryHeap.fix(); // Fix heap properties
+        return binaryHeap;
+    }
     /**
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
@@ -51,54 +77,6 @@ class Heap {
     pop() {
         return this.poll();
     }
-    /**
-     * Float operation to maintain heap properties after adding an element.
-     * @param index - The index of the newly added element.
-     */
-    bubbleUp(index) {
-        const element = this.nodes[index];
-        while (index > 0) {
-            const parentIndex = Math.floor((index - 1) / 2);
-            const parent = this.nodes[parentIndex];
-            if (this.comparator(element, parent) < 0) {
-                this.nodes[index] = parent;
-                this.nodes[parentIndex] = element;
-                index = parentIndex;
-            }
-            else {
-                break;
-            }
-        }
-    }
-    /**
-     * Sinking operation to maintain heap properties after removing the top element.
-     * @param index - The index from which to start sinking.
-     */
-    sinkDown(index) {
-        const leftChildIndex = 2 * index + 1;
-        const rightChildIndex = 2 * index + 2;
-        const length = this.nodes.length;
-        let targetIndex = index;
-        if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
-            targetIndex = leftChildIndex;
-        }
-        if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
-            targetIndex = rightChildIndex;
-        }
-        if (targetIndex !== index) {
-            const temp = this.nodes[index];
-            this.nodes[index] = this.nodes[targetIndex];
-            this.nodes[targetIndex] = temp;
-            this.sinkDown(targetIndex);
-        }
-    }
-    /**
-     * Fix the entire heap to maintain heap properties.
-     */
-    fix() {
-        for (let i = Math.floor(this.size / 2); i >= 0; i--)
-            this.sinkDown(i);
-    }
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
@@ -109,20 +87,6 @@ class Heap {
         }
         return this.nodes[0];
     }
-    /**
-     * Get the size (number of elements) of the heap.
-     */
-    get size() {
-        return this.nodes.length;
-    }
-    /**
-     * Get the last element in the heap, which is not necessarily a leaf node.
-     * @returns The last element or undefined if the heap is empty.
-     */
-    get leaf() {
-        var _a;
-        return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : undefined;
-    }
     /**
      * Check if the heap is empty.
      * @returns True if the heap is empty, otherwise false.
@@ -216,16 +180,52 @@ class Heap {
         return visitedNode;
     }
     /**
-     * Static method that creates a binary heap from an array of nodes and a comparison function.
-     * @param nodes
-     * @param comparator - Comparison function.
-     * @returns A new Heap instance.
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
      */
-    static heapify(nodes, comparator) {
-        const binaryHeap = new Heap(comparator);
-        binaryHeap.nodes = [...nodes];
-        binaryHeap.fix(); // Fix heap properties
-        return binaryHeap;
+    bubbleUp(index) {
+        const element = this.nodes[index];
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            const parent = this.nodes[parentIndex];
+            if (this.comparator(element, parent) < 0) {
+                this.nodes[index] = parent;
+                this.nodes[parentIndex] = element;
+                index = parentIndex;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     */
+    sinkDown(index) {
+        const leftChildIndex = 2 * index + 1;
+        const rightChildIndex = 2 * index + 2;
+        const length = this.nodes.length;
+        let targetIndex = index;
+        if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
+            targetIndex = leftChildIndex;
+        }
+        if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
+            targetIndex = rightChildIndex;
+        }
+        if (targetIndex !== index) {
+            const temp = this.nodes[index];
+            this.nodes[index] = this.nodes[targetIndex];
+            this.nodes[targetIndex] = temp;
+            this.sinkDown(targetIndex);
+        }
+    }
+    /**
+     * Fix the entire heap to maintain heap properties.
+     */
+    fix() {
+        for (let i = Math.floor(this.size / 2); i >= 0; i--)
+            this.sinkDown(i);
     }
 }
 exports.Heap = Heap;
@@ -246,19 +246,6 @@ class FibonacciHeap {
             throw new Error('FibonacciHeap constructor: given comparator should be a function.');
         }
     }
-    /**
-     * Default comparator function used by the heap.
-     * @param {E} a
-     * @param {E} b
-     * @protected
-     */
-    defaultComparator(a, b) {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    }
     /**
      * Get the size (number of elements) of the heap.
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
@@ -268,29 +255,6 @@ class FibonacciHeap {
         this.min = undefined;
         this.size = 0;
     }
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    createNode(element) {
-        return new FibonacciHeapNode(element);
-    }
-    /**
-     * Merge the given node with the root list.
-     * @param node - The node to be merged.
-     */
-    mergeWithRoot(node) {
-        if (!this.root) {
-            this.root = node;
-        }
-        else {
-            node.right = this.root.right;
-            node.left = this.root;
-            this.root.right.left = node;
-            this.root.right = node;
-        }
-    }
     /**
      * O(1) time operation.
      * Insert an element into the heap and maintain the heap properties.
@@ -351,20 +315,6 @@ class FibonacciHeap {
         }
         return nodes;
     }
-    /**
-     * O(log n) time operation.
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @param node - The node to be removed.
-     * @protected
-     */
-    removeFromRoot(node) {
-        if (this.root === node)
-            this.root = node.right;
-        if (node.left)
-            node.left.right = node.right;
-        if (node.right)
-            node.right.left = node.left;
-    }
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -382,52 +332,6 @@ class FibonacciHeap {
             parent.child.right = node;
         }
     }
-    /**
-     * O(log n) time operation.
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @param y
-     * @param x
-     * @protected
-     */
-    link(y, x) {
-        this.removeFromRoot(y);
-        y.left = y;
-        y.right = y;
-        this.mergeWithChild(x, y);
-        x.degree++;
-        y.parent = x;
-    }
-    /**
-     * O(log n) time operation.
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @protected
-     */
-    consolidate() {
-        const A = new Array(this.size);
-        const nodes = this.consumeLinkedList(this.root);
-        let x, y, d, t;
-        for (const node of nodes) {
-            x = node;
-            d = x.degree;
-            while (A[d]) {
-                y = A[d];
-                if (this.comparator(x.element, y.element) > 0) {
-                    t = x;
-                    x = y;
-                    y = t;
-                }
-                this.link(y, x);
-                A[d] = undefined;
-                d++;
-            }
-            A[d] = x;
-        }
-        for (let i = 0; i < this.size; i++) {
-            if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
-                this.min = A[i];
-            }
-        }
-    }
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -493,5 +397,101 @@ class FibonacciHeap {
         // Clear the heap that was merged
         heapToMerge.clear();
     }
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
+     * @protected
+     */
+    defaultComparator(a, b) {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    createNode(element) {
+        return new FibonacciHeapNode(element);
+    }
+    /**
+     * Merge the given node with the root list.
+     * @param node - The node to be merged.
+     */
+    mergeWithRoot(node) {
+        if (!this.root) {
+            this.root = node;
+        }
+        else {
+            node.right = this.root.right;
+            node.left = this.root;
+            this.root.right.left = node;
+            this.root.right = node;
+        }
+    }
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param node - The node to be removed.
+     * @protected
+     */
+    removeFromRoot(node) {
+        if (this.root === node)
+            this.root = node.right;
+        if (node.left)
+            node.left.right = node.right;
+        if (node.right)
+            node.right.left = node.left;
+    }
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param y
+     * @param x
+     * @protected
+     */
+    link(y, x) {
+        this.removeFromRoot(y);
+        y.left = y;
+        y.right = y;
+        this.mergeWithChild(x, y);
+        x.degree++;
+        y.parent = x;
+    }
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @protected
+     */
+    consolidate() {
+        const A = new Array(this.size);
+        const nodes = this.consumeLinkedList(this.root);
+        let x, y, d, t;
+        for (const node of nodes) {
+            x = node;
+            d = x.degree;
+            while (A[d]) {
+                y = A[d];
+                if (this.comparator(x.element, y.element) > 0) {
+                    t = x;
+                    x = y;
+                    y = t;
+                }
+                this.link(y, x);
+                A[d] = undefined;
+                d++;
+            }
+            A[d] = x;
+        }
+        for (let i = 0; i < this.size; i++) {
+            if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
+                this.min = A[i];
+            }
+        }
+    }
 }
 exports.FibonacciHeap = FibonacciHeap;

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -35,6 +35,7 @@ export declare class DoublyLinkedList<E = any> {
     set tail(value: DoublyLinkedListNode<E> | null);
     private _length;
     get length(): number;
+    get size(): number;
     /**
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
      * given array.
@@ -98,7 +99,6 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
     peekLast(): E | undefined;
-    get size(): number;
     /**
      * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -63,6 +63,9 @@ class DoublyLinkedList {
     get length() {
         return this._length;
     }
+    get size() {
+        return this.length;
+    }
     /**
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
      * given array.
@@ -198,9 +201,6 @@ class DoublyLinkedList {
         var _a;
         return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.val;
     }
-    get size() {
-        return this.length;
-    }
     /**
      * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -12,18 +12,6 @@ export declare class SkipListNode<K, V> {
     constructor(key: K, value: V, level: number);
 }
 export declare class SkipList<K, V> {
-    get probability(): number;
-    set probability(value: number);
-    get maxLevel(): number;
-    set maxLevel(value: number);
-    get level(): number;
-    set level(value: number);
-    get head(): SkipListNode<K, V>;
-    set head(value: SkipListNode<K, V>);
-    private _head;
-    private _level;
-    private _maxLevel;
-    private _probability;
     /**
      * The constructor initializes a SkipList with a specified maximum level and probability.
      * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
@@ -32,11 +20,18 @@ export declare class SkipList<K, V> {
      * level in the skip list. It is used to determine the height of each node in the skip list.
      */
     constructor(maxLevel?: number, probability?: number);
-    /**
-     * The function "randomLevel" generates a random level based on a given probability and maximum level.
-     * @returns the level, which is a number.
-     */
-    private randomLevel;
+    private _head;
+    get head(): SkipListNode<K, V>;
+    set head(value: SkipListNode<K, V>);
+    private _level;
+    get level(): number;
+    set level(value: number);
+    private _maxLevel;
+    get maxLevel(): number;
+    set maxLevel(value: number);
+    private _probability;
+    get probability(): number;
+    set probability(value: number);
     /**
      * The add function adds a new node with a given key and value to a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -58,4 +53,9 @@ export declare class SkipList<K, V> {
      * skip list, and `false` if the key was not found in the skip list.
      */
     delete(key: K): boolean;
+    /**
+     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * @returns the level, which is a number.
+     */
+    private randomLevel;
 }

package/dist/data-structures/linked-list/skip-linked-list.js

@@ -17,30 +17,6 @@ class SkipListNode {
 }
 exports.SkipListNode = SkipListNode;
 class SkipList {
-    get probability() {
-        return this._probability;
-    }
-    set probability(value) {
-        this._probability = value;
-    }
-    get maxLevel() {
-        return this._maxLevel;
-    }
-    set maxLevel(value) {
-        this._maxLevel = value;
-    }
-    get level() {
-        return this._level;
-    }
-    set level(value) {
-        this._level = value;
-    }
-    get head() {
-        return this._head;
-    }
-    set head(value) {
-        this._head = value;
-    }
     /**
      * The constructor initializes a SkipList with a specified maximum level and probability.
      * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
@@ -54,16 +30,29 @@ class SkipList {
         this._maxLevel = maxLevel;
         this._probability = probability;
     }
-    /**
-     * The function "randomLevel" generates a random level based on a given probability and maximum level.
-     * @returns the level, which is a number.
-     */
-    randomLevel() {
-        let level = 1;
-        while (Math.random() < this.probability && level < this.maxLevel) {
-            level++;
-        }
-        return level;
+    get head() {
+        return this._head;
+    }
+    set head(value) {
+        this._head = value;
+    }
+    get level() {
+        return this._level;
+    }
+    set level(value) {
+        this._level = value;
+    }
+    get maxLevel() {
+        return this._maxLevel;
+    }
+    set maxLevel(value) {
+        this._maxLevel = value;
+    }
+    get probability() {
+        return this._probability;
+    }
+    set probability(value) {
+        this._probability = value;
     }
     /**
      * The add function adds a new node with a given key and value to a Skip List data structure.
@@ -138,5 +127,16 @@ class SkipList {
         }
         return false;
     }
+    /**
+     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * @returns the level, which is a number.
+     */
+    randomLevel() {
+        let level = 1;
+        while (Math.random() < this.probability && level < this.maxLevel) {
+            level++;
+        }
+        return level;
+    }
 }
 exports.SkipList = SkipList;

package/dist/data-structures/matrix/matrix2d.d.ts

@@ -31,13 +31,6 @@ export declare class Matrix2D {
      * array of numbers.
      */
     get m(): number[][];
-    /**
-     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
-     * _matrix array.
-     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
-     * the first column of the matrix.
-     */
-    toVector(): Vector2D;
     /**
      * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
      * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.
@@ -104,5 +97,12 @@ export declare class Matrix2D {
      * @returns The method is returning a new instance of the Matrix2D class.
      */
     static translate(vector: Vector2D): Matrix2D;
+    /**
+     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
+     * _matrix array.
+     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
+     * the first column of the matrix.
+     */
+    toVector(): Vector2D;
 }
 export default Matrix2D;

package/dist/data-structures/matrix/matrix2d.js

@@ -59,15 +59,6 @@ class Matrix2D {
     get m() {
         return this._matrix;
     }
-    /**
-     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
-     * _matrix array.
-     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
-     * the first column of the matrix.
-     */
-    toVector() {
-        return new vector2d_1.default(this._matrix[0][0], this._matrix[1][0]);
-    }
     /**
      * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
      * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.
@@ -198,6 +189,15 @@ class Matrix2D {
             [0, 0, vector.w]
         ]);
     }
+    /**
+     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
+     * _matrix array.
+     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
+     * the first column of the matrix.
+     */
+    toVector() {
+        return new vector2d_1.default(this._matrix[0][0], this._matrix[1][0]);
+    }
 }
 exports.Matrix2D = Matrix2D;
 exports.default = Matrix2D;

package/dist/data-structures/trie/trie.d.ts

@@ -25,11 +25,11 @@ export declare class TrieNode {
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 export declare class Trie {
+    private readonly _caseSensitive;
     constructor(words?: string[], caseSensitive?: boolean);
     protected _root: TrieNode;
     get root(): TrieNode;
     set root(v: TrieNode);
-    private readonly _caseSensitive;
     /**
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -42,7 +42,6 @@ export declare class Trie {
      * @returns {boolean} True if the word is present in the Trie.
      */
     has(word: string): boolean;
-    private _caseProcess;
     /**
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
@@ -81,4 +80,5 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number): string[];
+    private _caseProcess;
 }

package/dist/data-structures/trie/trie.js

@@ -92,12 +92,6 @@ class Trie {
         }
         return cur.isEnd;
     }
-    _caseProcess(str) {
-        if (!this._caseSensitive) {
-            str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
-        }
-        return str;
-    }
     /**
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
@@ -264,5 +258,11 @@ class Trie {
             dfs(startNode, prefix);
         return words;
     }
+    _caseProcess(str) {
+        if (!this._caseSensitive) {
+            str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
+        }
+        return str;
+    }
 }
 exports.Trie = Trie;

package/dist/index.d.ts

@@ -5,6 +5,6 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export * from 'data-structure-typed/src/data-structures/heap';
-export * from 'data-structure-typed/src/types/data-structures/heap';
-export * from 'data-structure-typed/src/types/helpers';
+export * from './data-structures/heap';
+export * from './types/data-structures/heap';
+export * from './types/helpers';