min-heap-typed 1.49.5 → 1.49.7

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

@@ -21,23 +21,12 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export class Heap<E = any> extends IterableElementBase<E> {
-  options: HeapOptions<E>;
-
-  constructor(elements?: Iterable<E>, options?: HeapOptions<E>) {
+  constructor(elements: Iterable<E> = [], options?: HeapOptions<E>) {
     super();
-    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
-      };
+      const { comparator } = options;
+      if (comparator) this._comparator = comparator;
     }
 
     if (elements) {
@@ -48,6 +37,18 @@ export class Heap<E = any> extends IterableElementBase<E> {
     }
   }
 
+  protected _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;
+    }
+  };
+
+  get comparator() {
+    return this._comparator;
+  }
+
   protected _elements: E[] = [];
 
   get elements(): E[] {
@@ -278,7 +279,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>([], this.options);
+    const clonedHeap = new Heap<E>([], { comparator: this.comparator });
     clonedHeap._elements = [...this.elements];
     return clonedHeap;
   }
@@ -413,7 +414,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
     while (index > 0) {
       const parent = (index - 1) >> 1;
       const parentItem = this.elements[parent];
-      if (this.options.comparator(parentItem, element) <= 0) break;
+      if (this.comparator(parentItem, element) <= 0) break;
       this.elements[index] = parentItem;
       index = parent;
     }
@@ -435,11 +436,11 @@ export class Heap<E = any> extends IterableElementBase<E> {
       let left = (index << 1) | 1;
       const right = left + 1;
       let minItem = this.elements[left];
-      if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
+      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
         left = right;
         minItem = this.elements[right];
       }
-      if (this.options.comparator(minItem, element) >= 0) break;
+      if (this.comparator(minItem, element) >= 0) break;
       this.elements[index] = minItem;
       index = left;
     }

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

@@ -20,7 +20,7 @@ import { Heap } from './heap';
  */
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

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

@@ -20,7 +20,7 @@ import { Heap } from './heap';
  */
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

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

@@ -35,7 +35,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and size.
    */
-  constructor(elements?: Iterable<E>) {
+  constructor(elements: Iterable<E> = []) {
     super();
     this._head = undefined;
     this._tail = undefined;

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

@@ -27,11 +27,8 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
-  constructor(elements?: Iterable<E>) {
+  constructor(elements: Iterable<E> = []) {
     super();
-    this._head = undefined;
-    this._tail = undefined;
-    this._size = 0;
     if (elements) {
       for (const el of elements) this.push(el);
     }
@@ -49,7 +46,7 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return this._tail;
   }
 
-  protected _size: number;
+  protected _size: number = 0;
 
   get size(): number {
     return this._size;

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

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { SkipLinkedListOptions } from '../../types';
 
 export class SkipListNode<K, V> {
   key: K;
@@ -19,39 +20,37 @@ export class SkipListNode<K, V> {
 }
 
 export class SkipList<K, V> {
-  /**
-   * 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
-   * the maximum number of levels that can be created in the skip list.
-   * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
-   * level in the skip list. It is used to determine the height of each node in the skip list.
-   */
-  constructor(maxLevel = 16, probability = 0.5) {
-    this._head = new SkipListNode<K, V>(undefined as any, undefined as any, maxLevel);
-    this._level = 0;
-    this._maxLevel = maxLevel;
-    this._probability = probability;
+  constructor(elements: Iterable<[K, V]> = [], options?: SkipLinkedListOptions) {
+    if (options) {
+      const { maxLevel, probability } = options;
+      if (typeof maxLevel === 'number') this._maxLevel = maxLevel;
+      if (typeof probability === 'number') this._probability = probability;
+    }
+
+    if (elements) {
+      for (const [key, value] of elements) this.add(key, value);
+    }
   }
 
-  protected _head: SkipListNode<K, V>;
+  protected _head: SkipListNode<K, V> = new SkipListNode<K, V>(undefined as any, undefined as any, this.maxLevel);
 
   get head(): SkipListNode<K, V> {
     return this._head;
   }
 
-  protected _level: number;
+  protected _level: number = 0;
 
   get level(): number {
     return this._level;
   }
 
-  protected _maxLevel: number;
+  protected _maxLevel: number = 16;
 
   get maxLevel(): number {
     return this._maxLevel;
   }
 
-  protected _probability: number;
+  protected _probability: number = 0.5;
 
   get probability(): number {
     return this._probability;

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

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { MatrixOptions } from '../../types';
 
 export class Matrix {
   /**
@@ -14,16 +15,7 @@ export class Matrix {
    * @param [options] - The `options` parameter is an optional object that can contain the following
    * properties:
    */
-  constructor(
-    data: number[][],
-    options?: {
-      rows?: number;
-      cols?: number;
-      addFn?: (a: number, b: number) => any;
-      subtractFn?: (a: number, b: number) => any;
-      multiplyFn?: (a: number, b: number) => any;
-    }
-  ) {
+  constructor(data: number[][], options?: MatrixOptions) {
     if (options) {
       const { rows, cols, addFn, subtractFn, multiplyFn } = options;
       if (typeof rows === 'number' && rows > 0) this._rows = rows;

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

@@ -10,7 +10,7 @@ import { PriorityQueue } from './priority-queue';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: PriorityQueueOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

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

@@ -10,7 +10,7 @@ import { PriorityQueue } from './priority-queue';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: PriorityQueueOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

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

@@ -17,7 +17,7 @@ import { Heap } from '../heap';
  * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
  */
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>) {
+  constructor(elements: Iterable<E> = [], options?: PriorityQueueOptions<E>) {
     super(elements, options);
   }
 }

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback, IterableWithSizeOrLength } from '../../types';
+import type { DequeOptions, ElementCallback, IterableWithSizeOrLength } from '../../types';
 import { IterableElementBase } from '../base';
 import { calcMinUnitsRequired, rangeCheck } from '../../utils';
 
@@ -22,19 +22,16 @@ export class Deque<E> extends IterableElementBase<E> {
   protected _bucketLast = 0;
   protected _lastInBucket = 0;
   protected _bucketCount = 0;
-  protected readonly _bucketSize: number;
+  protected readonly _bucketSize: number = 1 << 12;
 
-  /**
-   * The constructor initializes a data structure with a specified bucket size and populates it with
-   * elements from an iterable.
-   * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
-   * contains the initial elements to be stored in the data structure. It can also be an object with a
-   * `length` property or a `size` property, which represents the number of elements in the iterable.
-   * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
-   * stored in each bucket. It determines the size of each bucket in the data structure.
-   */
-  constructor(elements: IterableWithSizeOrLength<E> = [], bucketSize = 1 << 12) {
+  constructor(elements: IterableWithSizeOrLength<E> = [], options?: DequeOptions) {
     super();
+
+    if (options) {
+      const { bucketSize } = options;
+      if (typeof bucketSize === 'number') this._bucketSize = bucketSize;
+    }
+
     let _size: number;
     if ('length' in elements) {
       if (elements.length instanceof Function) _size = elements.length();
@@ -44,7 +41,6 @@ export class Deque<E> extends IterableElementBase<E> {
       else _size = elements.size;
     }
 
-    this._bucketSize = bucketSize;
     this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
     for (let i = 0; i < this._bucketCount; ++i) {
       this._buckets.push(new Array(this._bucketSize));
@@ -637,7 +633,7 @@ export class Deque<E> extends IterableElementBase<E> {
    * satisfy the given predicate function.
    */
   filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Deque<E> {
-    const newDeque = new Deque<E>([], this._bucketSize);
+    const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -666,7 +662,7 @@ export class Deque<E> extends IterableElementBase<E> {
    * @returns a new Deque object with the mapped values.
    */
   map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T> {
-    const newDeque = new Deque<T>([], this._bucketSize);
+    const newDeque = new Deque<T>([], { bucketSize: this._bucketSize });
     let index = 0;
     for (const el of this) {
       newDeque.push(callback.call(thisArg, el, index, this));

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

@@ -13,29 +13,30 @@ import { SinglyLinkedList } from '../linked-list';
  * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
  * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
- * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
 export class Queue<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
    * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-   * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+   * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
    * initialized as an empty array.
    */
-  constructor(elements?: E[]) {
+  constructor(elements: Iterable<E> = []) {
     super();
-    this._nodes = elements || [];
-    this._offset = 0;
+    if (elements) {
+      for (const el of elements) this.push(el);
+    }
   }
 
-  protected _nodes: E[];
+  protected _elements: E[] = [];
 
-  get nodes(): E[] {
-    return this._nodes;
+  get elements(): E[] {
+    return this._elements;
   }
 
-  protected _offset: number;
+  protected _offset: number = 0;
 
   get offset(): number {
     return this._offset;
@@ -46,19 +47,19 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
    */
   get size(): number {
-    return this.nodes.length - this.offset;
+    return this.elements.length - this.offset;
   }
 
   /**
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
    *
-   * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-   * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+   * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+   * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
    * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
    */
   get first(): E | undefined {
-    return this.size > 0 ? this.nodes[this.offset] : undefined;
+    return this.size > 0 ? this.elements[this.offset] : undefined;
   }
 
   /**
@@ -71,11 +72,11 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(1) - no additional space is used.
    *
    * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-   * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+   * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
    * array is empty, it returns `undefined`.
    */
   get last(): E | undefined {
-    return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+    return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
   }
 
   /**
@@ -109,7 +110,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns The `add` method is returning a `Queue<E>` object.
    */
   push(element: E): boolean {
-    this.nodes.push(element);
+    this.elements.push(element);
     return true;
   }
 
@@ -132,11 +133,11 @@ export class Queue<E = any> extends IterableElementBase<E> {
     const first = this.first;
     this._offset += 1;
 
-    if (this.offset * 2 < this.nodes.length) return first;
+    if (this.offset * 2 < this.elements.length) return first;
 
     // only delete dequeued elements when reaching half size
     // to decrease latency of shifting elements.
-    this._nodes = this.nodes.slice(this.offset);
+    this._elements = this.elements.slice(this.offset);
     this._offset = 0;
     return first;
   }
@@ -150,8 +151,8 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
    *
-   * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-   * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+   * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+   * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
    * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
    */
   peek(): E | undefined {
@@ -168,7 +169,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(1) - no additional space is used.
    *
    * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-   * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+   * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
    * array is empty, it returns `undefined`.
    */
   peekLast(): E | undefined {
@@ -219,7 +220,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @param index
    */
   getAt(index: number): E | undefined {
-    return this.nodes[index];
+    return this.elements[index];
   }
 
   /**
@@ -247,18 +248,18 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
    * Space Complexity: O(n) - where n is the number of elements in the queue.
    *
-   * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+   * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
    * @returns An array of type E is being returned.
    */
   toArray(): E[] {
-    return this.nodes.slice(this.offset);
+    return this.elements.slice(this.offset);
   }
 
   /**
-   * The clear function resets the nodes array and offset to their initial values.
+   * The clear function resets the elements array and offset to their initial values.
    */
   clear(): void {
-    this._nodes = [];
+    this._elements = [];
     this._offset = 0;
   }
 
@@ -275,7 +276,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns The `clone()` method is returning a new instance of the `Queue` class.
    */
   clone(): Queue<E> {
-    return new Queue(this.nodes.slice(this.offset));
+    return new Queue(this.elements.slice(this.offset));
   }
 
   /**
@@ -345,7 +346,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    */
 
   protected* _getIterator(): IterableIterator<E> {
-    for (const item of this.nodes) {
+    for (const item of this.elements) {
       yield item;
     }
   }

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

@@ -23,17 +23,14 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * 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?: Iterable<E>) {
+  constructor(elements: Iterable<E> = []) {
     super();
-    this._elements = [];
     if (elements) {
-      for (const el of elements) {
-        this.push(el);
-      }
+      for (const el of elements) this.push(el);
     }
   }
 
-  protected _elements: E[];
+  protected _elements: E[] = [];
 
   get elements(): E[] {
     return this._elements;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, TrieOptions } from '../../types';
 import { IterableElementBase } from '../base';
 
 /**
@@ -38,31 +38,30 @@ export class TrieNode {
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export class Trie extends IterableElementBase<string> {
-  constructor(words?: string[], caseSensitive = true) {
+  constructor(words: Iterable<string> = [], options?: TrieOptions) {
     super();
-    this._root = new TrieNode('');
-    this._caseSensitive = caseSensitive;
-    this._size = 0;
+    if (options) {
+      const { caseSensitive } = options;
+      if (caseSensitive !== undefined) this._caseSensitive = caseSensitive;
+    }
     if (words) {
-      for (const word of words) {
-        this.add(word);
-      }
+      for (const word of words) this.add(word);
     }
   }
 
-  protected _size: number;
+  protected _size: number = 0;
 
   get size(): number {
     return this._size;
   }
 
-  protected _caseSensitive: boolean;
+  protected _caseSensitive: boolean = true;
 
   get caseSensitive(): boolean {
     return this._caseSensitive;
   }
 
-  protected _root: TrieNode;
+  protected _root: TrieNode = new TrieNode('');
 
   get root() {
     return this._root;

package/src/interfaces/binary-tree.ts

@@ -5,7 +5,7 @@ import {
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BTNCallback,
-  BTNExemplar
+  KeyOrNodeOrEntry
 } from '../types';
 
 export interface IBinaryTree<
@@ -18,9 +18,9 @@ export interface IBinaryTree<
 
   createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
 
-  add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
+  add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+  addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/src/types/common.ts

@@ -1,6 +1,6 @@
 export enum BSTVariant {
-  MIN = 'MIN',
-  MAX = 'MAX'
+  STANDARD = 'STANDARD',
+  INVERSE = 'INVERSE'
 }
 
 export enum CP {
@@ -54,7 +54,7 @@ export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
 
-export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
+export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 
 export type BTNodePureKeyOrNode<K, N> = K | N;
 

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

@@ -6,6 +6,6 @@ export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K,
 export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BinaryTreeOptions<K> = {
-  iterationType: IterationType,
-  extractor: (key: K) => number
+  iterationType?: IterationType,
+  extractor?: (key: K) => number
 }

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

@@ -7,5 +7,5 @@ export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTN
 export type BSTNested<K, V, N extends BSTNode<K, V, N>> = BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions<K> = BinaryTreeOptions<K> & {
-  variant: BSTVariant
+  variant?: BSTVariant
 }

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

@@ -5,4 +5,4 @@ export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNo
 
 export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultimapOptions<K> = Omit<AVLTreeOptions<K>, 'isMergeDuplicatedNodeByKey'> & {}
+export type TreeMultimapOptions<K> = AVLTreeOptions<K> & {}

package/src/types/data-structures/hash/hash-map.ts

@@ -5,9 +5,13 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
+export type LinkedHashMapOptions<K> = {
+  hashFn?: (key: K) => string;
+  objHashFn?: (key: K) => object;
+};
+
 export type HashMapOptions<K> = {
-  hashFn: (key: K) => string;
-  objHashFn: (key: K) => object;
+  hashFn?: (key: K) => string;
 };
 
 export type HashMapStoreItem<K, V> = { key: K; value: V };

package/src/types/data-structures/hash/index.ts

@@ -1,4 +1,3 @@
 export * from './hash-map';
-export * from './hash-table';
 
 export type HashFunction<K> = (key: K) => number;

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

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