heap-typed 1.38.0 → 1.38.2

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

@@ -15,6 +15,34 @@ export class Heap<E> {
     this.comparator = comparator;
   }
 
+  /**
+   * Get the size (number of elements) of the heap.
+   */
+  get size(): number {
+    return this.nodes.length;
+  }
+
+  /**
+   * Get the last element in the heap, which is not necessarily a leaf node.
+   * @returns The last element or undefined if the heap is empty.
+   */
+  get leaf(): E | undefined {
+    return this.nodes[this.size - 1] ?? undefined;
+  }
+
+  /**
+   * Static method that creates a binary heap from an array of nodes and a comparison function.
+   * @param nodes
+   * @param comparator - Comparison function.
+   * @returns A new Heap instance.
+   */
+  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
+    const binaryHeap = new Heap<E>(comparator);
+    binaryHeap.nodes = [...nodes];
+    binaryHeap.fix(); // Fix heap properties
+    return binaryHeap;
+  }
+
   /**
    * Insert an element into the heap and maintain the heap properties.
    * @param element - The element to be inserted.
@@ -59,57 +87,6 @@ export class Heap<E> {
     return this.poll();
   }
 
-  /**
-   * Float operation to maintain heap properties after adding an element.
-   * @param index - The index of the newly added element.
-   */
-  protected bubbleUp(index: number): void {
-    const element = this.nodes[index];
-    while (index > 0) {
-      const parentIndex = Math.floor((index - 1) / 2);
-      const parent = this.nodes[parentIndex];
-      if (this.comparator(element, parent) < 0) {
-        this.nodes[index] = parent;
-        this.nodes[parentIndex] = element;
-        index = parentIndex;
-      } else {
-        break;
-      }
-    }
-  }
-
-  /**
-   * Sinking operation to maintain heap properties after removing the top element.
-   * @param index - The index from which to start sinking.
-   */
-  protected sinkDown(index: number): void {
-    const leftChildIndex = 2 * index + 1;
-    const rightChildIndex = 2 * index + 2;
-    const length = this.nodes.length;
-    let targetIndex = index;
-
-    if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
-      targetIndex = leftChildIndex;
-    }
-    if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
-      targetIndex = rightChildIndex;
-    }
-
-    if (targetIndex !== index) {
-      const temp = this.nodes[index];
-      this.nodes[index] = this.nodes[targetIndex];
-      this.nodes[targetIndex] = temp;
-      this.sinkDown(targetIndex);
-    }
-  }
-
-  /**
-   * Fix the entire heap to maintain heap properties.
-   */
-  protected fix() {
-    for (let i = Math.floor(this.size / 2); i >= 0; i--) this.sinkDown(i);
-  }
-
   /**
    * Peek at the top element of the heap without removing it.
    * @returns The top element or undefined if the heap is empty.
@@ -121,21 +98,6 @@ export class Heap<E> {
     return this.nodes[0];
   }
 
-  /**
-   * Get the size (number of elements) of the heap.
-   */
-  get size(): number {
-    return this.nodes.length;
-  }
-
-  /**
-   * Get the last element in the heap, which is not necessarily a leaf node.
-   * @returns The last element or undefined if the heap is empty.
-   */
-  get leaf(): E | undefined {
-    return this.nodes[this.size - 1] ?? undefined;
-  }
-
   /**
    * Check if the heap is empty.
    * @returns True if the heap is empty, otherwise false.
@@ -238,16 +200,54 @@ export class Heap<E> {
   }
 
   /**
-   * Static method that creates a binary heap from an array of nodes and a comparison function.
-   * @param nodes
-   * @param comparator - Comparison function.
-   * @returns A new Heap instance.
+   * Float operation to maintain heap properties after adding an element.
+   * @param index - The index of the newly added element.
    */
-  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
-    const binaryHeap = new Heap<E>(comparator);
-    binaryHeap.nodes = [...nodes];
-    binaryHeap.fix(); // Fix heap properties
-    return binaryHeap;
+  protected bubbleUp(index: number): void {
+    const element = this.nodes[index];
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      const parent = this.nodes[parentIndex];
+      if (this.comparator(element, parent) < 0) {
+        this.nodes[index] = parent;
+        this.nodes[parentIndex] = element;
+        index = parentIndex;
+      } else {
+        break;
+      }
+    }
+  }
+
+  /**
+   * Sinking operation to maintain heap properties after removing the top element.
+   * @param index - The index from which to start sinking.
+   */
+  protected sinkDown(index: number): void {
+    const leftChildIndex = 2 * index + 1;
+    const rightChildIndex = 2 * index + 2;
+    const length = this.nodes.length;
+    let targetIndex = index;
+
+    if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
+      targetIndex = leftChildIndex;
+    }
+    if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
+      targetIndex = rightChildIndex;
+    }
+
+    if (targetIndex !== index) {
+      const temp = this.nodes[index];
+      this.nodes[index] = this.nodes[targetIndex];
+      this.nodes[targetIndex] = temp;
+      this.sinkDown(targetIndex);
+    }
+  }
+
+  /**
+   * Fix the entire heap to maintain heap properties.
+   */
+  protected fix() {
+    for (let i = Math.floor(this.size / 2); i >= 0; i--) this.sinkDown(i);
   }
 }
 
@@ -259,6 +259,7 @@ export class FibonacciHeapNode<E> {
   child?: FibonacciHeapNode<E>;
   parent?: FibonacciHeapNode<E>;
   marked: boolean;
+
   constructor(element: E, degree = 0) {
     this.element = element;
     this.degree = degree;
@@ -268,8 +269,8 @@ export class FibonacciHeapNode<E> {
 
 export class FibonacciHeap<E> {
   root?: FibonacciHeapNode<E>;
-  protected min?: FibonacciHeapNode<E>;
   size: number = 0;
+  protected min?: FibonacciHeapNode<E>;
   protected readonly comparator: Comparator<E>;
 
   constructor(comparator?: Comparator<E>) {
@@ -281,18 +282,6 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * Default comparator function used by the heap.
-   * @param {E} a
-   * @param {E} b
-   * @protected
-   */
-  protected defaultComparator(a: E, b: E): number {
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  }
-
   /**
    * Get the size (number of elements) of the heap.
    * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
@@ -303,30 +292,6 @@ export class FibonacciHeap<E> {
     this.size = 0;
   }
 
-  /**
-   * Create a new node.
-   * @param element
-   * @protected
-   */
-  protected createNode(element: E): FibonacciHeapNode<E> {
-    return new FibonacciHeapNode<E>(element);
-  }
-
-  /**
-   * Merge the given node with the root list.
-   * @param node - The node to be merged.
-   */
-  protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
-    if (!this.root) {
-      this.root = node;
-    } else {
-      node.right = this.root.right;
-      node.left = this.root;
-      this.root.right!.left = node;
-      this.root.right = node;
-    }
-  }
-
   /**
    * O(1) time operation.
    * Insert an element into the heap and maintain the heap properties.
@@ -394,18 +359,6 @@ export class FibonacciHeap<E> {
     return nodes;
   }
 
-  /**
-   * O(log n) time operation.
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @param node - The node to be removed.
-   * @protected
-   */
-  protected removeFromRoot(node: FibonacciHeapNode<E>): void {
-    if (this.root === node) this.root = node.right;
-    if (node.left) node.left.right = node.right;
-    if (node.right) node.right.left = node.left;
-  }
-
   /**
    * O(log n) time operation.
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -423,63 +376,6 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * O(log n) time operation.
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @param y
-   * @param x
-   * @protected
-   */
-  protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
-    this.removeFromRoot(y);
-    y.left = y;
-    y.right = y;
-    this.mergeWithChild(x, y);
-    x.degree++;
-    y.parent = x;
-  }
-
-  /**
-   * O(log n) time operation.
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @protected
-   */
-  protected consolidate(): void {
-    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
-    const nodes = this.consumeLinkedList(this.root);
-    let x: FibonacciHeapNode<E> | undefined,
-      y: FibonacciHeapNode<E> | undefined,
-      d: number,
-      t: FibonacciHeapNode<E> | undefined;
-
-    for (const node of nodes) {
-      x = node;
-      d = x.degree;
-
-      while (A[d]) {
-        y = A[d] as FibonacciHeapNode<E>;
-
-        if (this.comparator(x.element, y.element) > 0) {
-          t = x;
-          x = y;
-          y = t;
-        }
-
-        this.link(y, x);
-        A[d] = undefined;
-        d++;
-      }
-
-      A[d] = x;
-    }
-
-    for (let i = 0; i < this.size; i++) {
-      if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
-        this.min = A[i]!;
-      }
-    }
-  }
-
   /**
    * O(log n) time operation.
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -557,4 +453,109 @@ export class FibonacciHeap<E> {
     // Clear the heap that was merged
     heapToMerge.clear();
   }
+
+  /**
+   * Default comparator function used by the heap.
+   * @param {E} a
+   * @param {E} b
+   * @protected
+   */
+  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);
+  }
+
+  /**
+   * Merge the given node with the root list.
+   * @param node - The node to be merged.
+   */
+  protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
+    if (!this.root) {
+      this.root = node;
+    } else {
+      node.right = this.root.right;
+      node.left = this.root;
+      this.root.right!.left = node;
+      this.root.right = node;
+    }
+  }
+
+  /**
+   * O(log n) time operation.
+   * Remove and return the top element (smallest or largest element) from the heap.
+   * @param node - The node to be removed.
+   * @protected
+   */
+  protected removeFromRoot(node: FibonacciHeapNode<E>): void {
+    if (this.root === node) this.root = node.right;
+    if (node.left) node.left.right = node.right;
+    if (node.right) node.right.left = node.left;
+  }
+
+  /**
+   * O(log n) time operation.
+   * Remove and return the top element (smallest or largest element) from the heap.
+   * @param y
+   * @param x
+   * @protected
+   */
+  protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
+    this.removeFromRoot(y);
+    y.left = y;
+    y.right = y;
+    this.mergeWithChild(x, y);
+    x.degree++;
+    y.parent = x;
+  }
+
+  /**
+   * O(log n) time operation.
+   * Remove and return the top element (smallest or largest element) from the heap.
+   * @protected
+   */
+  protected consolidate(): void {
+    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
+    const nodes = this.consumeLinkedList(this.root);
+    let x: FibonacciHeapNode<E> | undefined,
+      y: FibonacciHeapNode<E> | undefined,
+      d: number,
+      t: FibonacciHeapNode<E> | undefined;
+
+    for (const node of nodes) {
+      x = node;
+      d = x.degree;
+
+      while (A[d]) {
+        y = A[d] as FibonacciHeapNode<E>;
+
+        if (this.comparator(x.element, y.element) > 0) {
+          t = x;
+          x = y;
+          y = t;
+        }
+
+        this.link(y, x);
+        A[d] = undefined;
+        d++;
+      }
+
+      A[d] = x;
+    }
+
+    for (let i = 0; i < this.size; i++) {
+      if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
+        this.min = A[i]!;
+      }
+    }
+  }
 }

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

@@ -84,6 +84,10 @@ export class DoublyLinkedList<E = any> {
     return this._length;
   }
 
+  get size(): number {
+    return this.length;
+  }
+
   /**
    * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
    * given array.
@@ -222,10 +226,6 @@ export class DoublyLinkedList<E = any> {
     return this.tail?.val;
   }
 
-  get size(): number {
-    return this.length;
-  }
-
   /**
    * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
    * @param {number} index - The index parameter is a number that represents the position of the element we want to

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

@@ -490,7 +490,7 @@ export class SinglyLinkedList<E = any> {
     return count;
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -19,20 +19,32 @@ export class SkipListNode<K, V> {
 }
 
 export class SkipList<K, V> {
-  get probability(): number {
-    return this._probability;
+  /**
+   * 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>(null as any, null as any, maxLevel);
+    this._level = 0;
+    this._maxLevel = maxLevel;
+    this._probability = probability;
   }
 
-  set probability(value: number) {
-    this._probability = value;
-  }
-  get maxLevel(): number {
-    return this._maxLevel;
+  private _head: SkipListNode<K, V>;
+
+  get head(): SkipListNode<K, V> {
+    return this._head;
   }
 
-  set maxLevel(value: number) {
-    this._maxLevel = value;
+  set head(value: SkipListNode<K, V>) {
+    this._head = value;
   }
+
+  private _level: number;
+
   get level(): number {
     return this._level;
   }
@@ -40,42 +52,25 @@ export class SkipList<K, V> {
   set level(value: number) {
     this._level = value;
   }
-  get head(): SkipListNode<K, V> {
-    return this._head;
+
+  private _maxLevel: number;
+
+  get maxLevel(): number {
+    return this._maxLevel;
   }
 
-  set head(value: SkipListNode<K, V>) {
-    this._head = value;
+  set maxLevel(value: number) {
+    this._maxLevel = value;
   }
-  private _head: SkipListNode<K, V>;
-  private _level: number;
-  private _maxLevel: number;
+
   private _probability: number;
 
-  /**
-   * 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>(null as any, null as any, maxLevel);
-    this._level = 0;
-    this._maxLevel = maxLevel;
-    this._probability = probability;
+  get probability(): number {
+    return this._probability;
   }
 
-  /**
-   * The function "randomLevel" generates a random level based on a given probability and maximum level.
-   * @returns the level, which is a number.
-   */
-  private randomLevel(): number {
-    let level = 1;
-    while (Math.random() < this.probability && level < this.maxLevel) {
-      level++;
-    }
-    return level;
+  set probability(value: number) {
+    this._probability = value;
   }
 
   /**
@@ -163,4 +158,16 @@ export class SkipList<K, V> {
 
     return false;
   }
+
+  /**
+   * The function "randomLevel" generates a random level based on a given probability and maximum level.
+   * @returns the level, which is a number.
+   */
+  private randomLevel(): number {
+    let level = 1;
+    while (Math.random() < this.probability && level < this.maxLevel) {
+      level++;
+    }
+    return level;
+  }
 }

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

@@ -14,7 +14,7 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: {row: number; col: number; initialVal?: V}) {
+  constructor(options: { row: number; col: number; initialVal?: V }) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

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

@@ -58,16 +58,6 @@ export class Matrix2D {
     return this._matrix;
   }
 
-  /**
-   * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
-   * _matrix array.
-   * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
-   * the first column of the matrix.
-   */
-  toVector(): Vector2D {
-    return new Vector2D(this._matrix[0][0], this._matrix[1][0]);
-  }
-
   /**
    * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
    * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.
@@ -208,6 +198,16 @@ export class Matrix2D {
       [0, 0, vector.w]
     ]);
   }
+
+  /**
+   * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
+   * _matrix array.
+   * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
+   * the first column of the matrix.
+   */
+  toVector(): Vector2D {
+    return new Vector2D(this._matrix[0][0], this._matrix[1][0]);
+  }
 }
 
 export default Matrix2D;

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

@@ -10,7 +10,8 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {}
+  ) {
+  }
 
   /**
    * The function checks if the x and y values of a point are both zero.

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

@@ -9,7 +9,8 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {}
+export class Deque<E = any> extends DoublyLinkedList<E> {
+}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -19,9 +20,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  private _nodes: {[key: number]: E} = {};
+  private _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 
@@ -156,7 +157,7 @@ export class ObjectDeque<E = number> {
     return this._size <= 0;
   }
 
-  protected _seNodes(value: {[p: number]: E}) {
+  protected _seNodes(value: { [p: number]: E }) {
     this._nodes = value;
   }
 

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

@@ -183,7 +183,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }