min-heap-typed 1.49.1 → 1.49.2

package/dist/data-structures/base/iterable-base.d.ts

@@ -126,6 +126,12 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * all the elements in the collection.
      */
     reduce<U>(callbackfn: ReduceEntryCallback<K, V, U>, initialValue: U): U;
+    hasValue(value: V): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print(): void;
     protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 export declare abstract class IterableElementBase<V> {
@@ -228,5 +234,10 @@ export declare abstract class IterableElementBase<V> {
      * all the elements in the array and applying the callback function to each element.
      */
     reduce<U>(callbackfn: ReduceElementCallback<V, U>, initialValue: U): U;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print(): void;
     protected abstract _getIterator(...args: any[]): IterableIterator<V>;
 }

package/dist/data-structures/base/iterable-base.js

@@ -172,6 +172,20 @@ class IterableEntryBase {
         }
         return accumulator;
     }
+    hasValue(value) {
+        for (const [, elementValue] of this) {
+            if (elementValue === value)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print() {
+        console.log([...this]);
+    }
 }
 exports.IterableEntryBase = IterableEntryBase;
 class IterableElementBase {
@@ -308,5 +322,12 @@ class IterableElementBase {
         }
         return accumulator;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print() {
+        console.log([...this]);
+    }
 }
 exports.IterableElementBase = IterableElementBase;

package/dist/data-structures/hash/hash-map.d.ts

@@ -42,13 +42,13 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      * @param {V} value - The value parameter represents the value that you want to associate with the
      * key in the data structure.
      */
-    set(key: K, value: V): void;
+    set(key: K, value: V): boolean;
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
      * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
      * key-value pair is represented as an array with two elements: the key and the value.
      */
-    setMany(elements: Iterable<[K, V]>): void;
+    setMany(elements: Iterable<[K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -114,6 +114,7 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
     print(): void;
+    put(key: K, value: V): boolean;
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
      * object map.
@@ -178,10 +179,9 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * value associated with the key being set in the data structure.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key: K, value?: V): number;
+    set(key: K, value?: V): boolean;
     has(key: K): boolean;
-    hasValue(value: V): boolean;
-    setMany(entries: Iterable<[K, V]>): void;
+    setMany(entries: Iterable<[K, V]>): boolean[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -207,7 +207,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
      * where `K` is the key and `V` is the value.
      */
-    getAt(index: number): [K, V];
+    getAt(index: number): V | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -228,7 +228,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * deleted in the linked list.
      * @returns The size of the list after deleting the element at the specified index.
      */
-    deleteAt(index: number): number;
+    deleteAt(index: number): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -288,7 +288,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * function.
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
-    print(): void;
+    put(key: K, value: V): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
@@ -306,5 +306,5 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * represents a node in a linked list. It contains a key-value pair and references to the previous
      * and next nodes in the list.
      */
-    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): void;
+    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): boolean;
 }

package/dist/data-structures/hash/hash-map.js

@@ -68,6 +68,7 @@ class HashMap extends base_1.IterableEntryBase {
             }
             this._store[strKey] = { key, value };
         }
+        return true;
     }
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
@@ -75,8 +76,10 @@ class HashMap extends base_1.IterableEntryBase {
      * key-value pair is represented as an array with two elements: the key and the value.
      */
     setMany(elements) {
+        const results = [];
         for (const [key, value] of elements)
-            this.set(key, value);
+            results.push(this.set(key, value));
+        return results;
     }
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
@@ -194,6 +197,9 @@ class HashMap extends base_1.IterableEntryBase {
     print() {
         console.log([...this.entries()]);
     }
+    put(key, value) {
+        return this.set(key, value);
+    }
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
      * object map.
@@ -357,7 +363,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             this._sentinel.prev = node;
             this._size++;
         }
-        return this._size;
+        return true;
     }
     has(key) {
         if ((0, utils_1.isWeakKey)(key)) {
@@ -369,18 +375,13 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             return hash in this._noObjMap;
         }
     }
-    hasValue(value) {
-        for (const [, elementValue] of this) {
-            if (elementValue === value)
-                return true;
-        }
-        return false;
-    }
     setMany(entries) {
+        const results = [];
         for (const entry of entries) {
             const [key, value] = entry;
-            this.set(key, value);
+            results.push(this.set(key, value));
         }
+        return results;
     }
     /**
      * Time Complexity: O(1)
@@ -424,7 +425,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         while (index--) {
             node = node.next;
         }
-        return [node.key, node.value];
+        return node.value;
     }
     /**
      * Time Complexity: O(1)
@@ -477,8 +478,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         while (index--) {
             node = node.next;
         }
-        this._deleteNode(node);
-        return this._size;
+        return this._deleteNode(node);
     }
     /**
      * Time Complexity: O(1)
@@ -571,8 +571,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return mappedMap;
     }
-    print() {
-        console.log([...this]);
+    put(key, value) {
+        return this.set(key, value);
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
@@ -608,6 +608,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             this._tail = prev;
         }
         this._size -= 1;
+        return true;
     }
 }
 exports.LinkedHashMap = LinkedHashMap;

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

@@ -52,19 +52,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
      */
-    add(element: E): Heap<E>;
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
-     */
-    push(element: E): Heap<E>;
+    add(element: E): boolean;
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
@@ -77,18 +65,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @returns The top element or undefined if the heap is empty.
      */
     poll(): E | undefined;
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
-     */
-    pop(): E | undefined;
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
@@ -114,7 +90,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Clear and add elements of the heap
      * @param elements
      */
-    refill(elements: E[]): void;
+    refill(elements: E[]): boolean[];
     /**
      * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
@@ -203,7 +179,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      *
      * Fix the entire heap to maintain heap properties.
      */
-    fix(): void;
+    fix(): boolean[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -250,12 +226,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * original Heap.
      */
     map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    print(): void;
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -267,7 +238,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Float operation to maintain heap properties after adding an element.
      * @param index - The index of the newly added element.
      */
-    protected _bubbleUp(index: number): void;
+    protected _bubbleUp(index: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -276,7 +247,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param index - The index from which to start sinking.
      * @param halfLength
      */
-    protected _sinkDown(index: number, halfLength: number): void;
+    protected _sinkDown(index: number, halfLength: number): boolean;
 }
 export declare class FibonacciHeapNode<E> {
     element: E;

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

@@ -42,7 +42,7 @@ class Heap extends base_1.IterableElementBase {
         }
         if (elements) {
             for (const el of elements) {
-                this.push(el);
+                this.add(el);
             }
             // this.fix();
         }
@@ -85,23 +85,8 @@ class Heap extends base_1.IterableElementBase {
      * @param element - The element to be inserted.
      */
     add(element) {
-        return this.push(element);
-    }
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
-     */
-    push(element) {
         this._elements.push(element);
-        this._bubbleUp(this.elements.length - 1);
-        return this;
+        return this._bubbleUp(this.elements.length - 1);
     }
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
@@ -125,20 +110,6 @@ class Heap extends base_1.IterableElementBase {
         }
         return value;
     }
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
-     */
-    pop() {
-        return this.poll();
-    }
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
@@ -172,7 +143,7 @@ class Heap extends base_1.IterableElementBase {
      */
     refill(elements) {
         this._elements = elements;
-        this.fix();
+        return this.fix();
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the heap.
@@ -209,7 +180,7 @@ class Heap extends base_1.IterableElementBase {
         if (index < 0)
             return false;
         if (index === 0) {
-            this.pop();
+            this.poll();
         }
         else if (index === this.elements.length - 1) {
             this.elements.pop();
@@ -321,8 +292,10 @@ class Heap extends base_1.IterableElementBase {
      * Fix the entire heap to maintain heap properties.
      */
     fix() {
+        const results = [];
         for (let i = Math.floor(this.size / 2); i >= 0; i--)
-            this._sinkDown(i, this.elements.length >> 1);
+            results.push(this._sinkDown(i, this.elements.length >> 1));
+        return results;
     }
     /**
      * Time Complexity: O(n)
@@ -349,7 +322,7 @@ class Heap extends base_1.IterableElementBase {
         let index = 0;
         for (const current of this) {
             if (callback.call(thisArg, current, index, this)) {
-                filteredList.push(current);
+                filteredList.add(current);
             }
             index++;
         }
@@ -388,13 +361,6 @@ class Heap extends base_1.IterableElementBase {
         }
         return mappedHeap;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         for (const element of this.elements) {
             yield element;
@@ -422,6 +388,7 @@ class Heap extends base_1.IterableElementBase {
             index = parent;
         }
         this.elements[index] = element;
+        return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -448,6 +415,7 @@ class Heap extends base_1.IterableElementBase {
             index = left;
         }
         this.elements[index] = element;
+        return true;
     }
 }
 exports.Heap = Heap;