data-structure-typed 1.47.5 → 1.47.7

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -589,7 +589,7 @@ export class AbstractGraph {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new PriorityQueue({ comparator: (a, b) => a.key - b.key });
+        const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);

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

@@ -14,12 +14,7 @@ export declare class HashMap<K = any, V = any> {
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
     protected _hashFn: (key: K) => string;
     protected _objHashFn: (key: K) => object;
-    /**
-     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-     * @param options - The `options` parameter is an object that contains the `elements` property. The
-     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-     */
-    constructor(options?: HashMapOptions<K, V>);
+    constructor(elements?: Iterable<[K, V]>, options?: HashMapOptions<K>);
     protected _size: number;
     get size(): number;
     /**
@@ -172,6 +167,7 @@ export declare class HashMap<K = any, V = any> {
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
     [Symbol.iterator](): Generator<[K, V], void, unknown>;
+    print(): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -14,19 +14,13 @@ export class HashMap {
     _sentinel;
     _hashFn;
     _objHashFn;
-    /**
-     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-     * @param options - The `options` parameter is an object that contains the `elements` property. The
-     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-     */
-    constructor(options = {
-        elements: [],
+    constructor(elements, options = {
         hashFn: (key) => String(key),
         objHashFn: (key) => key
     }) {
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        const { elements, hashFn, objHashFn } = options;
+        const { hashFn, objHashFn } = options;
         this._hashFn = hashFn;
         this._objHashFn = objHashFn;
         if (elements) {
@@ -349,6 +343,9 @@ export class HashMap {
             node = node.next;
         }
     }
+    print() {
+        console.log([...this]);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/mjs/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>;
     /**
@@ -204,6 +201,11 @@ export declare class Heap<E = any> {
      * 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)
@@ -212,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)
@@ -349,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)
@@ -399,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)
@@ -411,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/mjs/data-structures/heap/heap.js

@@ -5,21 +5,35 @@
  * @license MIT License
  */
 export class Heap {
-    constructor(options) {
-        this._comparator = options.comparator;
-        if (options.elements && options.elements.length > 0) {
-            this._elements = options.elements;
-            this.fix();
+    options;
+    constructor(elements, options) {
+        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();
         }
     }
     _elements = [];
     get elements() {
         return this._elements;
     }
-    _comparator;
-    get comparator() {
-        return this._comparator;
-    }
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -36,10 +50,11 @@ export 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.
@@ -253,7 +268,7 @@ export 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;
     }
@@ -305,7 +320,7 @@ export class Heap {
         }
     }
     filter(predicate) {
-        const filteredHeap = new Heap({ comparator: this.comparator });
+        const filteredHeap = new Heap([], this.options);
         let index = 0;
         for (const el of this) {
             if (predicate(el, index, this)) {
@@ -316,7 +331,7 @@ export class Heap {
         return filteredHeap;
     }
     map(callback, comparator) {
-        const mappedHeap = new Heap({ comparator: comparator });
+        const mappedHeap = new Heap([], { comparator: comparator });
         let index = 0;
         for (const el of this) {
             mappedHeap.add(callback(el, index, this));
@@ -337,6 +352,13 @@ export class Heap {
      * 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)
@@ -349,17 +371,13 @@ export 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)
@@ -375,11 +393,11 @@ export 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;
@@ -404,7 +422,7 @@ export class FibonacciHeapNode {
 export class FibonacciHeap {
     constructor(comparator) {
         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.');
         }
@@ -579,7 +597,7 @@ export class FibonacciHeap {
         }
         else {
             this._min = z.right;
-            this.consolidate();
+            this._consolidate();
         }
         this._size--;
         return z.element;
@@ -619,27 +637,27 @@ export 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)
@@ -695,7 +713,7 @@ export class FibonacciHeap {
      * @param x
      * @protected
      */
-    link(y, x) {
+    _link(y, x) {
         this.removeFromRoot(y);
         y.left = y;
         y.right = y;
@@ -714,7 +732,7 @@ export 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;
@@ -728,7 +746,7 @@ export class FibonacciHeap {
                     x = y;
                     y = t;
                 }
-                this.link(y, x);
+                this._link(y, x);
                 A[d] = undefined;
                 d++;
             }

package/dist/mjs/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/mjs/data-structures/heap/max-heap.js

@@ -7,7 +7,7 @@
  */
 import { Heap } from './heap';
 export class MaxHeap extends 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');
@@ -17,6 +17,6 @@ export class MaxHeap extends Heap {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }

package/dist/mjs/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/mjs/data-structures/heap/min-heap.js

@@ -7,7 +7,7 @@
  */
 import { Heap } from './heap';
 export class MinHeap extends 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');
@@ -17,6 +17,6 @@ export class MinHeap extends Heap {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }

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

@@ -20,7 +20,7 @@ export declare class DoublyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor();
+    constructor(elements?: Iterable<E>);
     protected _head: DoublyLinkedListNode<E> | null;
     get head(): DoublyLinkedListNode<E> | null;
     protected _tail: DoublyLinkedListNode<E> | null;
@@ -453,4 +453,5 @@ export declare class DoublyLinkedList<E = any> {
      * elements in the linked list.
      */
     reduce<T>(callback: (accumulator: T, value: E, index: number, list: DoublyLinkedList<E>) => T, initialValue: T): T;
+    print(): void;
 }

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

@@ -24,10 +24,15 @@ export class DoublyLinkedList {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
         this._head = null;
         this._tail = null;
         this._length = 0;
+        if (elements) {
+            for (const el of elements) {
+                this.push(el);
+            }
+        }
     }
     _head;
     get head() {
@@ -766,4 +771,7 @@ export class DoublyLinkedList {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
 }

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -19,7 +19,7 @@ export declare class SinglyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor();
+    constructor(elements?: Iterable<E>);
     protected _head: SinglyLinkedListNode<E> | null;
     get head(): SinglyLinkedListNode<E> | null;
     protected _tail: SinglyLinkedListNode<E> | null;
@@ -411,4 +411,5 @@ export declare class SinglyLinkedList<E = any> {
      * elements in the linked list.
      */
     reduce<T>(callback: (accumulator: T, value: E, index: number, list: SinglyLinkedList<E>) => T, initialValue: T): T;
+    print(): void;
 }

package/dist/mjs/data-structures/linked-list/singly-linked-list.js

@@ -22,10 +22,14 @@ export class SinglyLinkedList {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
         this._head = null;
         this._tail = null;
         this._length = 0;
+        if (elements) {
+            for (const el of elements)
+                this.push(el);
+        }
     }
     _head;
     get head() {
@@ -710,4 +714,7 @@ export class SinglyLinkedList {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
 }

package/dist/mjs/data-structures/priority-queue/max-priority-queue.d.ts

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

package/dist/mjs/data-structures/priority-queue/max-priority-queue.js

@@ -7,7 +7,7 @@
  */
 import { PriorityQueue } from './priority-queue';
 export class MaxPriorityQueue extends PriorityQueue {
-    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');
@@ -17,6 +17,6 @@ export class MaxPriorityQueue extends PriorityQueue {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }

package/dist/mjs/data-structures/priority-queue/min-priority-queue.d.ts

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

package/dist/mjs/data-structures/priority-queue/min-priority-queue.js

@@ -7,7 +7,7 @@
  */
 import { PriorityQueue } from './priority-queue';
 export class MinPriorityQueue extends PriorityQueue {
-    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');
@@ -17,6 +17,6 @@ export class MinPriorityQueue extends PriorityQueue {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }

package/dist/mjs/data-structures/priority-queue/priority-queue.d.ts

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

package/dist/mjs/data-structures/priority-queue/priority-queue.js

@@ -7,7 +7,7 @@
  */
 import { Heap } from '../heap';
 export class PriorityQueue extends Heap {
-    constructor(options) {
-        super(options);
+    constructor(elements, options) {
+        super(elements, options);
     }
 }

package/dist/mjs/data-structures/queue/deque.d.ts

@@ -428,6 +428,7 @@ export declare class Deque<E> {
      * applying the callback function to each element.
      */
     reduce<T>(callback: (accumulator: T, element: E, index: number, deque: this) => T, initialValue: T): T;
+    print(): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/mjs/data-structures/queue/deque.js

@@ -759,6 +759,9 @@ export class Deque {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/mjs/data-structures/queue/queue.d.ts

@@ -205,6 +205,7 @@ export declare class Queue<E = any> {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone(): Queue<E>;
+    print(): void;
     [Symbol.iterator](): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n)

package/dist/mjs/data-structures/queue/queue.js

@@ -262,6 +262,9 @@ export class Queue {
     clone() {
         return new Queue(this.nodes.slice(this.offset));
     }
+    print() {
+        console.log([...this]);
+    }
     *[Symbol.iterator]() {
         for (const item of this.nodes) {
             yield item;

package/dist/mjs/data-structures/stack/stack.d.ts

@@ -10,7 +10,7 @@ export declare class Stack<E = any> {
      * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
-    constructor(elements?: E[]);
+    constructor(elements?: Iterable<E>);
     protected _elements: E[];
     get elements(): E[];
     /**
@@ -116,4 +116,5 @@ export declare class Stack<E = any> {
     filter(predicate: (element: E, index: number, stack: this) => boolean): Stack<E>;
     map<T>(callback: (element: E, index: number, stack: this) => T): Stack<T>;
     reduce<T>(callback: (accumulator: T, element: E, index: number, stack: this) => T, initialValue: T): T;
+    print(): void;
 }