data-structure-typed 1.47.5 → 1.47.6

package/src/data-structures/heap/heap.ts

@@ -6,13 +6,32 @@
  */
 
 import type { Comparator, DFSOrderPattern } from '../../types';
+import { HeapOptions } from "../../types";
 
 export class Heap<E = any> {
-  constructor(options: { comparator: Comparator<E>; elements?: E[] }) {
-    this._comparator = options.comparator;
-    if (options.elements && options.elements.length > 0) {
-      this._elements = options.elements;
-      this.fix();
+  options: HeapOptions<E>;
+
+  constructor(elements?: Iterable<E>, options?: HeapOptions<E>) {
+    const defaultComparator = (a: E, b: E) => {
+      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();
     }
   }
 
@@ -22,12 +41,6 @@ export class Heap<E = any> {
     return this._elements;
   }
 
-  protected _comparator: Comparator<E>;
-
-  get comparator(): Comparator<E> {
-    return this._comparator;
-  }
-
   /**
    * Get the size (number of elements) of the heap.
    */
@@ -46,10 +59,11 @@ export 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[]; comparator: Comparator<E> }): Heap<E> {
-    return new Heap<E>(options);
+  static heapify<E>(elements: Iterable<E>, options: { comparator: Comparator<E> }): Heap<E> {
+    return new Heap<E>(elements, options);
   }
 
   /**
@@ -283,7 +297,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>({ comparator: this.comparator });
+    const clonedHeap = new Heap<E>([], this.options);
     clonedHeap._elements = [...this.elements];
     return clonedHeap;
   }
@@ -340,7 +354,7 @@ export class Heap<E = any> {
   }
 
   filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E> {
-    const filteredHeap: Heap<E> = new Heap<E>({ comparator: this.comparator });
+    const filteredHeap: Heap<E> = new Heap<E>([], this.options);
     let index = 0;
     for (const el of this) {
       if (predicate(el, index, this)) {
@@ -353,7 +367,7 @@ export class Heap<E = any> {
 
   map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T> {
 
-    const mappedHeap: Heap<T> = new Heap<T>({ comparator: comparator });
+    const mappedHeap: Heap<T> = new Heap<T>([], { comparator: comparator });
     let index = 0;
     for (const el of this) {
       mappedHeap.add(callback(el, index, this));
@@ -380,6 +394,15 @@ export class Heap<E = any> {
    * Space Complexity: O(1)
    */
 
+  print(): void {
+    console.log([...this]);
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -392,18 +415,13 @@ export class Heap<E = any> {
     while (index > 0) {
       const parent = (index - 1) >> 1;
       const parentItem = this.elements[parent];
-      if (this._comparator(parentItem, element) <= 0) break;
+      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)
@@ -420,12 +438,12 @@ export class Heap<E = any> {
       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) break;
+      if (this.options.comparator(minItem, element) >= 0) break;
       this.elements[index] = minItem;
       index = left;
     }
@@ -452,7 +470,7 @@ export class FibonacciHeapNode<E> {
 export class FibonacciHeap<E> {
   constructor(comparator?: Comparator<E>) {
     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.');
@@ -653,7 +671,7 @@ export class FibonacciHeap<E> {
       this._root = undefined;
     } else {
       this._min = z.right;
-      this.consolidate();
+      this._consolidate();
     }
 
     this._size--;
@@ -705,27 +723,27 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
+  /**
+   * Create a new node.
+   * @param element
+   * @protected
+   */
+  createNode(element: E): FibonacciHeapNode<E> {
+    return new FibonacciHeapNode<E>(element);
+  }
+
   /**
    * Default comparator function used by the heap.
    * @param {E} a
    * @param {E} b
    * @protected
    */
-  protected defaultComparator(a: E, b: E): number {
+  protected _defaultComparator(a: E, b: E): number {
     if (a < b) return -1;
     if (a > b) return 1;
     return 0;
   }
 
-  /**
-   * Create a new node.
-   * @param element
-   * @protected
-   */
-  protected createNode(element: E): FibonacciHeapNode<E> {
-    return new FibonacciHeapNode<E>(element);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -782,7 +800,7 @@ export class FibonacciHeap<E> {
    * @param x
    * @protected
    */
-  protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
+  protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
     this.removeFromRoot(y);
     y.left = y;
     y.right = y;
@@ -803,7 +821,7 @@ export class FibonacciHeap<E> {
    * Remove and return the top element (smallest or largest element) from the heap.
    * @protected
    */
-  protected consolidate(): void {
+  protected _consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
     const elements = this.consumeLinkedList(this.root);
     let x: FibonacciHeapNode<E> | undefined,
@@ -824,7 +842,7 @@ export class FibonacciHeap<E> {
           y = t;
         }
 
-        this.link(y, x);
+        this._link(y, x);
         A[d] = undefined;
         d++;
       }

package/src/data-structures/heap/max-heap.ts

@@ -7,11 +7,12 @@
  */
 
 import { Heap } from './heap';
-import type { Comparator } from '../../types';
+import type { HeapOptions } from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    elements?: Iterable<E>,
+    options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');
@@ -19,8 +20,7 @@ export class MaxHeap<E = any> extends Heap<E> {
           return b - a;
         }
       }
-    }
-  ) {
-    super(options);
+    }) {
+    super(elements, options);
   }
 }

package/src/data-structures/heap/min-heap.ts

@@ -7,11 +7,12 @@
  */
 
 import { Heap } from './heap';
-import type { Comparator } from '../../types';
+import type { HeapOptions } from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    elements?: Iterable<E>,
+    options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');
@@ -19,8 +20,7 @@ export class MinHeap<E = any> extends Heap<E> {
           return a - b;
         }
       }
-    }
-  ) {
-    super(options);
+    }) {
+    super(elements, options);
   }
 }

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -26,10 +26,15 @@ export class DoublyLinkedList<E = any> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
-  constructor() {
+  constructor(elements?: Iterable<E>) {
     this._head = null;
     this._tail = null;
     this._length = 0;
+    if (elements) {
+      for (const el of elements) {
+        this.push(el);
+      }
+    }
   }
 
   protected _head: DoublyLinkedListNode<E> | null;
@@ -834,4 +839,8 @@ export class DoublyLinkedList<E = any> {
 
     return accumulator;
   }
+
+  print(): void {
+    console.log([...this]);
+  }
 }

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -24,10 +24,14 @@ export class SinglyLinkedList<E = any> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
-  constructor() {
+  constructor(elements?: Iterable<E>) {
     this._head = null;
     this._tail = null;
     this._length = 0;
+    if (elements) {
+      for (const el of elements)
+        this.push(el);
+    }
   }
 
   protected _head: SinglyLinkedListNode<E> | null;
@@ -781,4 +785,8 @@ export class SinglyLinkedList<E = any> {
 
     return accumulator;
   }
+
+  print(): void {
+    console.log([...this]);
+  }
 }

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -6,11 +6,12 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { Comparator } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    elements?: Iterable<E>,
+    options: PriorityQueueOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');
@@ -20,6 +21,6 @@ export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
       }
     }
   ) {
-    super(options);
+    super(elements, options);
   }
 }

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -6,20 +6,20 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { Comparator } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-  constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
-      comparator: (a: E, b: E) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-          throw new Error('The a, b params of compare function must be number');
-        } else {
-          return a - b;
-        }
-      }
-    }
+  constructor(elements?: Iterable<E>,
+              options: PriorityQueueOptions<E> = {
+                comparator: (a: E, b: E) => {
+                  if (!(typeof a === 'number' && typeof b === 'number')) {
+                    throw new Error('The a, b params of compare function must be number');
+                  } else {
+                    return a - b;
+                  }
+                }
+              }
   ) {
-    super(options);
+    super(elements, options);
   }
 }

package/src/data-structures/priority-queue/priority-queue.ts

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

package/src/data-structures/queue/deque.ts

@@ -819,6 +819,10 @@ export class Deque<E> {
     return accumulator;
   }
 
+  print(): void {
+    console.log([...this])
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)

package/src/data-structures/queue/queue.ts

@@ -300,6 +300,10 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
+  print(): void {
+    console.log([...this]);
+  }
+
   * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;

package/src/data-structures/stack/stack.ts

@@ -10,8 +10,13 @@ export 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[]) {
-    this._elements = Array.isArray(elements) ? elements : [];
+  constructor(elements?: Iterable<E>) {
+    this._elements = [];
+    if (elements) {
+      for (const el of elements) {
+        this.push(el);
+      }
+    }
   }
 
   protected _elements: E[];
@@ -153,7 +158,7 @@ export class Stack<E = any> {
    * @returns An iterator object.
    */
   * [Symbol.iterator]() {
-    for (let i = this.elements.length - 1; i >= 0; i--) {
+    for (let i = 0; i < this.elements.length; i++) {
       yield this.elements[i];
     }
   }
@@ -203,4 +208,8 @@ export class Stack<E = any> {
     }
     return accumulator;
   }
+
+  print(): void {
+    console.log([...this]);
+  }
 }

package/src/interfaces/binary-tree.ts

@@ -1,9 +1,21 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeNested, BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
+import {
+  BinaryTreeNested,
+  BinaryTreeNodeNested,
+  BinaryTreeOptions,
+  BiTreeDeleteResult,
+  BTNCallback,
+  BTNKey,
+  IterableEntriesOrKeys
+} from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
   createNode(key: BTNKey, value?: N['value']): N;
 
+  createTree(options?: Partial<BinaryTreeOptions>): TREE;
+
+  init(elements: IterableEntriesOrKeys<V>): void;
+
   add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];

package/src/types/common.ts

@@ -1,3 +1,5 @@
+import { BTNKey } from "./data-structures";
+
 export type Comparator<T> = (a: T, b: T) => number;
 
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
@@ -20,4 +22,6 @@ export interface IterableWithLength<T> extends Iterable<T> {
 
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>
 
-export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
+export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
+
+export type IterableEntriesOrKeys<T> = Iterable<[BTNKey, T | undefined] | BTNKey>

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -30,6 +30,6 @@ export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, Binary
 
 export type BinaryTreeNested<T, N extends BinaryTreeNode<T, N>> = BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type BinaryTreeOptions = { iterationType?: IterationType }
+export type BinaryTreeOptions = { iterationType: IterationType }
 
 export type NodeDisplayLayout = [string[], number, number, number];

package/src/types/data-structures/binary-tree/bst.ts

@@ -1,7 +1,6 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions, BTNKey } from './binary-tree';
-
-export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
+import { Comparator } from "../../common";
 
 // prettier-ignore
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
@@ -9,5 +8,5 @@ export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNo
 export type BSTNested<T, N extends BSTNode<T, N>> = BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions = BinaryTreeOptions & {
-  comparator?: BSTComparator,
+  comparator: Comparator<BTNKey>
 }

package/src/types/data-structures/heap/heap.ts

@@ -1 +1,3 @@
-export {};
+import { Comparator } from "../../common";
+
+export type HeapOptions<T> = { comparator: Comparator<T> }

package/src/types/data-structures/priority-queue/priority-queue.ts

@@ -1 +1,3 @@
-export {};
+import { HeapOptions } from "../heap";
+
+export type PriorityQueueOptions<T> = HeapOptions<T> & {}

package/test/performance/data-structures/comparison/comparison.test.ts

@@ -23,17 +23,18 @@ const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSA
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new SRCPriorityQueue<number>([], { comparator: (a, b) => b - a });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new CJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+
+    const pq = new CJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new MJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   });
 
@@ -47,19 +48,19 @@ if (isCompetitor) {
 
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new SRCPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new CJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new CJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new MJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();

package/test/performance/data-structures/heap/heap.test.ts

@@ -7,7 +7,7 @@ const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
-    const heap = new Heap<number>({ comparator: (a, b) => b - a });
+    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       heap.add(i);
@@ -18,7 +18,7 @@ suite
     }
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {
-    const heap = new Heap<number>({ comparator: (a, b) => b - a });
+    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       heap.add(i);

package/test/performance/data-structures/priority-queue/priority-queue.test.ts

@@ -8,7 +8,7 @@ const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND } = magnitude;
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
-  const pq = new PriorityQueue<number>({ comparator: (a, b) => b - a });
+  const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
   for (let i = 0; i < HUNDRED_THOUSAND; i++) {
     pq.add(i);

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -112,7 +112,7 @@ describe('AVL Tree Test', () => {
 describe('AVL Tree Test recursively', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>({ iterationType: IterationType.RECURSIVE });
+    const tree = new AVLTree<number>([], { iterationType: IterationType.RECURSIVE });
 
     for (const i of arr) tree.add(i, i);
 

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -189,9 +189,9 @@ describe('BinaryTree', () => {
     tree.add(4);
     tree.add(2);
     expect(tree.getHeight()).toBe(1);
-    tree.options.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = IterationType.RECURSIVE;
     expect(tree.getHeight()).toBe(1);
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
 
     tree.add(6);
     tree.add(1);
@@ -381,7 +381,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<string>({ iterationType: IterationType.RECURSIVE });
+    tree = new BinaryTree<string>([], { iterationType: IterationType.RECURSIVE });
   });
 
   afterEach(() => {
@@ -541,11 +541,11 @@ describe('BinaryTree', () => {
     tree.add(3, 'B');
     tree.add(7, 'C');
 
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
-    tree.options.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = IterationType.RECURSIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
 
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -395,7 +395,7 @@ describe('BST operations test', () => {
 
 describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST({ iterationType: IterationType.RECURSIVE });
+    const bst = new BST([], { iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
     bst.add(11, 11);
     bst.add(3, 3);