priority-queue-typed 1.47.5 → 1.47.7

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/data-structures/trie/trie.ts

@@ -29,13 +29,20 @@ export class Trie {
   constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
     this._caseSensitive = caseSensitive;
+    this._size = 0;
     if (words) {
-      for (const i of words) {
-        this.add(i);
+      for (const word of words) {
+        this.add(word);
       }
     }
   }
 
+  protected _size: number;
+
+  get size(): number {
+    return this._size;
+  }
+
   protected _caseSensitive: boolean;
 
   get caseSensitive(): boolean {
@@ -64,6 +71,7 @@ export class Trie {
   add(word: string): boolean {
     word = this._caseProcess(word);
     let cur = this.root;
+    let isNewWord = false;
     for (const c of word) {
       let nodeC = cur.children.get(c);
       if (!nodeC) {
@@ -72,8 +80,12 @@ export class Trie {
       }
       cur = nodeC;
     }
-    cur.isEnd = true;
-    return true;
+    if (!cur.isEnd) {
+      isNewWord = true;
+      cur.isEnd = true;
+      this._size++;
+    }
+    return isNewWord;
   }
 
   /**
@@ -143,6 +155,9 @@ export class Trie {
     };
 
     dfs(this.root, 0);
+    if (isDeleted) {
+      this._size--;
+    }
     return isDeleted;
   }
 
@@ -377,6 +392,10 @@ export class Trie {
     return accumulator;
   }
 
+  print() {
+    console.log([...this]);
+  }
+
   /**
    * Time Complexity: O(M), where M is the length of the input string.
    * Space Complexity: O(1) - Constant space.

package/src/interfaces/binary-tree.ts

@@ -1,10 +1,22 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeNested, BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
+import {
+  BinaryTreeNested,
+  BinaryTreeNodeNested,
+  BinaryTreeOptions,
+  BiTreeDeleteResult,
+  BTNCallback,
+  BTNKey,
+  BTNodeExemplar,
+} 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;
 
-  add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
+  createTree(options?: Partial<BinaryTreeOptions>): TREE;
+
+  add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | null | undefined;
+
+  addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (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,16 @@ 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 BTNodeEntry<T> = [BTNKey | null | undefined, T | undefined];
+
+export type BTNodeKeyOrNode<N> = BTNKey | null | undefined | N;
+
+export type BTNodeExemplar<T, N> = BTNodeEntry<T> | BTNodeKeyOrNode<N>
+
+export type BTNodePureExemplar<T, N> = [BTNKey, T | undefined] | BTNodePureKeyOrNode<N>
+
+export type BTNodePureKeyOrNode<N> = BTNKey | N;
+
+export type BSTNodeKeyOrNode<N> = BTNKey | undefined | N;

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/hash/hash-map.ts

@@ -5,8 +5,7 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
-export type HashMapOptions<K, V> = {
-  elements: Iterable<[K, V]>;
+export type HashMapOptions<K> = {
   hashFn: (key: K) => string;
   objHashFn: (key: K) => object
 }

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> & {}