avl-tree-typed 1.47.4 → 1.47.6

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

@@ -8,11 +8,11 @@
 export declare class HashTableNode<K, V> {
     key: K;
     value: V;
-    next: HashTableNode<K, V> | null;
+    next: HashTableNode<K, V> | undefined;
     constructor(key: K, value: V);
 }
 import { HashFunction } from '../../types';
-export declare class HashTable<K, V> {
+export declare class HashTable<K = any, V = any> {
     protected static readonly DEFAULT_CAPACITY = 16;
     protected static readonly LOAD_FACTOR = 0.75;
     constructor(capacity?: number, hashFn?: HashFunction<K>);
@@ -20,8 +20,8 @@ export declare class HashTable<K, V> {
     get capacity(): number;
     protected _size: number;
     get size(): number;
-    protected _buckets: Array<HashTableNode<K, V> | null>;
-    get buckets(): Array<HashTableNode<K, V> | null>;
+    protected _buckets: Array<HashTableNode<K, V> | undefined>;
+    get buckets(): Array<HashTableNode<K, V> | undefined>;
     protected _hashFn: HashFunction<K>;
     get hashFn(): HashFunction<K>;
     /**
@@ -50,6 +50,11 @@ export declare class HashTable<K, V> {
      * any value.
      */
     delete(key: K): void;
+    [Symbol.iterator](): Generator<[K, V], void, undefined>;
+    forEach(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => void): void;
+    filter(predicate: (entry: [K, V], index: number, table: HashTable<K, V>) => boolean): HashTable<K, V>;
+    map<T>(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => T): HashTable<K, T>;
+    reduce<T>(callback: (accumulator: T, entry: [K, V], index: number, table: HashTable<K, V>) => T, initialValue: T): T;
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.

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

@@ -12,7 +12,7 @@ class HashTableNode {
     constructor(key, value) {
         this.key = key;
         this.value = value;
-        this.next = null;
+        this.next = undefined;
     }
 }
 exports.HashTableNode = HashTableNode;
@@ -21,7 +21,7 @@ class HashTable {
         this._hashFn = hashFn || this._defaultHashFn;
         this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
         this._size = 0;
-        this._buckets = new Array(this._capacity).fill(null);
+        this._buckets = new Array(this._capacity).fill(undefined);
     }
     get capacity() {
         return this._capacity;
@@ -101,7 +101,7 @@ class HashTable {
     delete(key) {
         const index = this._hash(key);
         let currentNode = this._buckets[index];
-        let prevNode = null;
+        let prevNode = undefined;
         while (currentNode) {
             if (currentNode.key === key) {
                 if (prevNode) {
@@ -111,13 +111,58 @@ class HashTable {
                     this._buckets[index] = currentNode.next;
                 }
                 this._size--;
-                currentNode.next = null; // Release memory
+                currentNode.next = undefined; // Release memory
                 return;
             }
             prevNode = currentNode;
             currentNode = currentNode.next;
         }
     }
+    *[Symbol.iterator]() {
+        for (const bucket of this._buckets) {
+            let currentNode = bucket;
+            while (currentNode) {
+                yield [currentNode.key, currentNode.value];
+                currentNode = currentNode.next;
+            }
+        }
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const entry of this) {
+            callback(entry, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const newTable = new HashTable();
+        let index = 0;
+        for (const [key, value] of this) {
+            if (predicate([key, value], index, this)) {
+                newTable.set(key, value);
+            }
+            index++;
+        }
+        return newTable;
+    }
+    map(callback) {
+        const newTable = new HashTable();
+        let index = 0;
+        for (const [key, value] of this) {
+            newTable.set(key, callback([key, value], index, this));
+            index++;
+        }
+        return newTable;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const entry of this) {
+            accumulator = callback(accumulator, entry, index, this);
+            index++;
+        }
+        return accumulator;
+    }
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.
@@ -208,7 +253,7 @@ class HashTable {
      */
     _expand() {
         const newCapacity = this._capacity * 2;
-        const newBuckets = new Array(newCapacity).fill(null);
+        const newBuckets = new Array(newCapacity).fill(undefined);
         for (const bucket of this._buckets) {
             let currentNode = bucket;
             while (currentNode) {

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

@@ -5,15 +5,12 @@
  * @license MIT License
  */
 import type { Comparator, DFSOrderPattern } from '../../types';
+import { HeapOptions } from "../../types";
 export declare class Heap<E = any> {
-    constructor(options: {
-        comparator: Comparator<E>;
-        elements?: E[];
-    });
+    options: HeapOptions<E>;
+    constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
     protected _elements: E[];
     get elements(): E[];
-    protected _comparator: Comparator<E>;
-    get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -26,10 +23,10 @@ export declare class Heap<E = any> {
     /**
      * Static method that creates a binary heap from an array of elements and a comparison function.
      * @returns A new Heap instance.
+     * @param elements
      * @param options
      */
-    static heapify<E>(options: {
-        elements: E[];
+    static heapify<E>(elements: Iterable<E>, options: {
         comparator: Comparator<E>;
     }): Heap<E>;
     /**
@@ -147,7 +144,7 @@ export declare class Heap<E = any> {
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order: DFSOrderPattern): E[];
+    dfs(order?: DFSOrderPattern): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -195,10 +192,20 @@ export declare class Heap<E = any> {
      * Fix the entire heap to maintain heap properties.
      */
     fix(): void;
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    forEach(callback: (element: E, index: number, heap: this) => void): void;
+    filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E>;
+    map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T>;
+    reduce<T>(callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T, initialValue: T): T;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
+    print(): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -207,10 +214,6 @@ export declare class Heap<E = any> {
      * @param index - The index of the newly added element.
      */
     protected _bubbleUp(index: number): void;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -344,18 +347,18 @@ export declare class FibonacciHeap<E> {
      */
     merge(heapToMerge: FibonacciHeap<E>): void;
     /**
-     * Default comparator function used by the heap.
-     * @param {E} a
-     * @param {E} b
+     * Create a new node.
+     * @param element
      * @protected
      */
-    protected defaultComparator(a: E, b: E): number;
+    createNode(element: E): FibonacciHeapNode<E>;
     /**
-     * Create a new node.
-     * @param element
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
      * @protected
      */
-    protected createNode(element: E): FibonacciHeapNode<E>;
+    protected _defaultComparator(a: E, b: E): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -394,7 +397,7 @@ export declare class FibonacciHeap<E> {
      * @param x
      * @protected
      */
-    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
+    protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
      * Time Complexity: O(n log n), where n is the number of elements in the heap.
      * Space Complexity: O(n)
@@ -406,5 +409,5 @@ export declare class FibonacciHeap<E> {
      * Remove and return the top element (smallest or largest element) from the heap.
      * @protected
      */
-    protected consolidate(): void;
+    protected _consolidate(): void;
 }

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

@@ -8,20 +8,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 class Heap {
-    constructor(options) {
+    constructor(elements, options) {
         this._elements = [];
-        this._comparator = options.comparator;
-        if (options.elements && options.elements.length > 0) {
-            this._elements = options.elements;
-            this.fix();
+        const defaultComparator = (a, b) => {
+            if (!(typeof a === 'number' && typeof b === 'number')) {
+                throw new Error('The a, b params of compare function must be number');
+            }
+            else {
+                return a - b;
+            }
+        };
+        if (options) {
+            this.options = options;
+        }
+        else {
+            this.options = {
+                comparator: defaultComparator
+            };
+        }
+        if (elements) {
+            for (const el of elements) {
+                this.push(el);
+            }
+            // this.fix();
         }
     }
     get elements() {
         return this._elements;
     }
-    get comparator() {
-        return this._comparator;
-    }
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -39,10 +53,11 @@ class Heap {
     /**
      * Static method that creates a binary heap from an array of elements and a comparison function.
      * @returns A new Heap instance.
+     * @param elements
      * @param options
      */
-    static heapify(options) {
-        return new Heap(options);
+    static heapify(elements, options) {
+        return new Heap(elements, options);
     }
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
@@ -204,29 +219,30 @@ class Heap {
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order) {
+    dfs(order = 'pre') {
         const result = [];
         // Auxiliary recursive function, traverses the binary heap according to the traversal order
-        const dfsHelper = (index) => {
+        const _dfs = (index) => {
+            const left = 2 * index + 1, right = left + 1;
             if (index < this.size) {
                 if (order === 'in') {
-                    dfsHelper(2 * index + 1);
+                    _dfs(left);
                     result.push(this.elements[index]);
-                    dfsHelper(2 * index + 2);
+                    _dfs(right);
                 }
                 else if (order === 'pre') {
                     result.push(this.elements[index]);
-                    dfsHelper(2 * index + 1);
-                    dfsHelper(2 * index + 2);
+                    _dfs(left);
+                    _dfs(right);
                 }
                 else if (order === 'post') {
-                    dfsHelper(2 * index + 1);
-                    dfsHelper(2 * index + 2);
+                    _dfs(left);
+                    _dfs(right);
                     result.push(this.elements[index]);
                 }
             }
         };
-        dfsHelper(0); // Traverse starting from the root node
+        _dfs(0); // Traverse starting from the root node
         return result;
     }
     /**
@@ -255,7 +271,7 @@ class Heap {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-        const clonedHeap = new Heap({ comparator: this.comparator });
+        const clonedHeap = new Heap([], this.options);
         clonedHeap._elements = [...this.elements];
         return clonedHeap;
     }
@@ -294,10 +310,58 @@ class Heap {
         for (let i = Math.floor(this.size / 2); i >= 0; i--)
             this._sinkDown(i, this.elements.length >> 1);
     }
+    *[Symbol.iterator]() {
+        for (const element of this.elements) {
+            yield element;
+        }
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const filteredHeap = new Heap([], this.options);
+        let index = 0;
+        for (const el of this) {
+            if (predicate(el, index, this)) {
+                filteredHeap.push(el);
+            }
+            index++;
+        }
+        return filteredHeap;
+    }
+    map(callback, comparator) {
+        const mappedHeap = new Heap([], { comparator: comparator });
+        let index = 0;
+        for (const el of this) {
+            mappedHeap.add(callback(el, index, this));
+            index++;
+        }
+        return mappedHeap;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
+        }
+        return accumulator;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
+    print() {
+        console.log([...this]);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -310,17 +374,13 @@ class Heap {
         while (index > 0) {
             const parent = (index - 1) >> 1;
             const parentItem = this.elements[parent];
-            if (this._comparator(parentItem, element) <= 0)
+            if (this.options.comparator(parentItem, element) <= 0)
                 break;
             this.elements[index] = parentItem;
             index = parent;
         }
         this.elements[index] = element;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -336,11 +396,11 @@ class Heap {
             const right = left + 1;
             let minItem = this.elements[left];
             if (right < this.elements.length &&
-                this._comparator(minItem, this.elements[right]) > 0) {
+                this.options.comparator(minItem, this.elements[right]) > 0) {
                 left = right;
                 minItem = this.elements[right];
             }
-            if (this._comparator(minItem, element) >= 0)
+            if (this.options.comparator(minItem, element) >= 0)
                 break;
             this.elements[index] = minItem;
             index = left;
@@ -361,7 +421,7 @@ class FibonacciHeap {
     constructor(comparator) {
         this._size = 0;
         this.clear();
-        this._comparator = comparator || this.defaultComparator;
+        this._comparator = comparator || this._defaultComparator;
         if (typeof this.comparator !== 'function') {
             throw new Error('FibonacciHeap constructor: given comparator should be a function.');
         }
@@ -532,7 +592,7 @@ class FibonacciHeap {
         }
         else {
             this._min = z.right;
-            this.consolidate();
+            this._consolidate();
         }
         this._size--;
         return z.element;
@@ -572,27 +632,27 @@ class FibonacciHeap {
         // Clear the heap that was merged
         heapToMerge.clear();
     }
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    createNode(element) {
+        return new FibonacciHeapNode(element);
+    }
     /**
      * Default comparator function used by the heap.
      * @param {E} a
      * @param {E} b
      * @protected
      */
-    defaultComparator(a, b) {
+    _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);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -648,7 +708,7 @@ class FibonacciHeap {
      * @param x
      * @protected
      */
-    link(y, x) {
+    _link(y, x) {
         this.removeFromRoot(y);
         y.left = y;
         y.right = y;
@@ -667,7 +727,7 @@ class FibonacciHeap {
      * Remove and return the top element (smallest or largest element) from the heap.
      * @protected
      */
-    consolidate() {
+    _consolidate() {
         const A = new Array(this.size);
         const elements = this.consumeLinkedList(this.root);
         let x, y, d, t;
@@ -681,7 +741,7 @@ class FibonacciHeap {
                     x = y;
                     y = t;
                 }
-                this.link(y, x);
+                this._link(y, x);
                 A[d] = undefined;
                 d++;
             }

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

@@ -6,10 +6,7 @@
  * @license MIT License
  */
 import { Heap } from './heap';
-import type { Comparator } from '../../types';
+import type { HeapOptions } from '../../types';
 export declare class MaxHeap<E = any> extends Heap<E> {
-    constructor(options?: {
-        comparator: Comparator<E>;
-        nodes?: E[];
-    });
+    constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
 }

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

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxHeap = void 0;
 const heap_1 = require("./heap");
 class MaxHeap extends heap_1.Heap {
-    constructor(options = {
+    constructor(elements, options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');
@@ -20,7 +20,7 @@ class MaxHeap extends heap_1.Heap {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }
 exports.MaxHeap = MaxHeap;

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

@@ -6,10 +6,7 @@
  * @license MIT License
  */
 import { Heap } from './heap';
-import type { Comparator } from '../../types';
+import type { HeapOptions } from '../../types';
 export declare class MinHeap<E = any> extends Heap<E> {
-    constructor(options?: {
-        comparator: Comparator<E>;
-        nodes?: E[];
-    });
+    constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
 }

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

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinHeap = void 0;
 const heap_1 = require("./heap");
 class MinHeap extends heap_1.Heap {
-    constructor(options = {
+    constructor(elements, options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');
@@ -20,7 +20,7 @@ class MinHeap extends heap_1.Heap {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }
 exports.MinHeap = MinHeap;