min-heap-typed 1.39.6 → 1.40.0

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

@@ -8,17 +8,26 @@
 import type {Comparator, DFSOrderPattern} from '../../types';
 
 export class Heap<E = any> {
-  protected nodes: E[] = [];
-  protected readonly comparator: Comparator<E>;
-
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
-    this.comparator = options.comparator;
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+    this._comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
-      this.nodes = options.nodes;
+      this._nodes = options.nodes;
       this.fix();
     }
   }
 
+  protected _nodes: E[] = [];
+
+  get nodes(): E[] {
+    return this._nodes;
+  }
+
+  protected _comparator: Comparator<E>;
+
+  get comparator(): Comparator<E> {
+    return this._comparator;
+  }
+
   /**
    * Get the size (number of elements) of the heap.
    */
@@ -39,7 +48,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
+  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
     return new Heap<E>(options);
   }
 
@@ -110,7 +119,7 @@ export class Heap<E = any> {
    * Reset the nodes of the heap. Make the nodes empty.
    */
   clear() {
-    this.nodes = [];
+    this._nodes = [];
   }
 
   /**
@@ -118,7 +127,7 @@ export class Heap<E = any> {
    * @param nodes
    */
   refill(nodes: E[]) {
-    this.nodes = nodes;
+    this._nodes = nodes;
     this.fix();
   }
 
@@ -181,7 +190,7 @@ export class Heap<E = any> {
    */
   clone(): Heap<E> {
     const clonedHeap = new Heap<E>({comparator: this.comparator});
-    clonedHeap.nodes = [...this.nodes];
+    clonedHeap._nodes = [...this.nodes];
     return clonedHeap;
   }
 
@@ -268,28 +277,47 @@ export class FibonacciHeapNode<E> {
 }
 
 export class FibonacciHeap<E> {
-  root?: FibonacciHeapNode<E>;
-  size = 0;
-  protected min?: FibonacciHeapNode<E>;
-  protected readonly comparator: Comparator<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.');
     }
   }
 
+  protected _root?: FibonacciHeapNode<E>;
+
+  get root(): FibonacciHeapNode<E> | undefined {
+    return this._root;
+  }
+
+  protected _size = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
+  protected _min?: FibonacciHeapNode<E>;
+
+  get min(): FibonacciHeapNode<E> | undefined {
+    return this._min;
+  }
+
+  protected _comparator: Comparator<E>;
+
+  get comparator(): Comparator<E> {
+    return this._comparator;
+  }
+
   /**
    * 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.
    */
   clear(): void {
-    this.root = undefined;
-    this.min = undefined;
-    this.size = 0;
+    this._root = undefined;
+    this._min = undefined;
+    this._size = 0;
   }
 
   /**
@@ -315,10 +343,10 @@ export class FibonacciHeap<E> {
     this.mergeWithRoot(node);
 
     if (!this.min || this.comparator(node.element, this.min.element) <= 0) {
-      this.min = node;
+      this._min = node;
     }
 
-    this.size++;
+    this._size++;
     return this;
   }
 
@@ -405,14 +433,14 @@ export class FibonacciHeap<E> {
     this.removeFromRoot(z);
 
     if (z === z.right) {
-      this.min = undefined;
-      this.root = undefined;
+      this._min = undefined;
+      this._root = undefined;
     } else {
-      this.min = z.right;
+      this._min = z.right;
       this.consolidate();
     }
 
-    this.size--;
+    this._size--;
 
     return z.element;
   }
@@ -444,11 +472,11 @@ export class FibonacciHeap<E> {
 
     // Update the minimum node
     if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {
-      this.min = heapToMerge.min;
+      this._min = heapToMerge.min;
     }
 
     // Update the size
-    this.size += heapToMerge.size;
+    this._size += heapToMerge.size;
 
     // Clear the heap that was merged
     heapToMerge.clear();
@@ -481,7 +509,7 @@ export class FibonacciHeap<E> {
    */
   protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
     if (!this.root) {
-      this.root = node;
+      this._root = node;
     } else {
       node.right = this.root.right;
       node.left = this.root;
@@ -497,7 +525,7 @@ export class FibonacciHeap<E> {
    * @protected
    */
   protected removeFromRoot(node: FibonacciHeapNode<E>): void {
-    if (this.root === node) this.root = node.right;
+    if (this.root === node) this._root = node.right;
     if (node.left) node.left.right = node.right;
     if (node.right) node.right.left = node.left;
   }
@@ -554,7 +582,7 @@ export class FibonacciHeap<E> {
 
     for (let i = 0; i < this.size; i++) {
       if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
-        this.min = A[i]!;
+        this._min = A[i]!;
       }
     }
   }

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

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    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');

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

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    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');

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

@@ -6,45 +6,19 @@
  * @license MIT License
  */
 export class DoublyLinkedListNode<E = any> {
+  value: E;
+  next: DoublyLinkedListNode<E> | null;
+  prev: DoublyLinkedListNode<E> | null;
+
   /**
    * The constructor function initializes the value, next, and previous properties of an object.
    * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
    * is defined as a generic type "E".
    */
   constructor(value: E) {
-    this._value = value;
-    this._next = null;
-    this._prev = null;
-  }
-
-  private _value: E;
-
-  get value(): E {
-    return this._value;
-  }
-
-  set value(value: E) {
-    this._value = value;
-  }
-
-  private _next: DoublyLinkedListNode<E> | null;
-
-  get next(): DoublyLinkedListNode<E> | null {
-    return this._next;
-  }
-
-  set next(value: DoublyLinkedListNode<E> | null) {
-    this._next = value;
-  }
-
-  private _prev: DoublyLinkedListNode<E> | null;
-
-  get prev(): DoublyLinkedListNode<E> | null {
-    return this._prev;
-  }
-
-  set prev(value: DoublyLinkedListNode<E> | null) {
-    this._prev = value;
+    this.value = value;
+    this.next = null;
+    this.prev = null;
   }
 }
 
@@ -58,27 +32,19 @@ export class DoublyLinkedList<E = any> {
     this._length = 0;
   }
 
-  private _head: DoublyLinkedListNode<E> | null;
+  protected _head: DoublyLinkedListNode<E> | null;
 
   get head(): DoublyLinkedListNode<E> | null {
     return this._head;
   }
 
-  set head(value: DoublyLinkedListNode<E> | null) {
-    this._head = value;
-  }
-
-  private _tail: DoublyLinkedListNode<E> | null;
+  protected _tail: DoublyLinkedListNode<E> | null;
 
   get tail(): DoublyLinkedListNode<E> | null {
     return this._tail;
   }
 
-  set tail(value: DoublyLinkedListNode<E> | null) {
-    this._tail = value;
-  }
-
-  private _length: number;
+  protected _length: number;
 
   get length(): number {
     return this._length;
@@ -109,12 +75,12 @@ export class DoublyLinkedList<E = any> {
   push(value: E): void {
     const newNode = new DoublyLinkedListNode(value);
     if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
+      this._head = newNode;
+      this._tail = newNode;
     } else {
       newNode.prev = this.tail;
       this.tail!.next = newNode;
-      this.tail = newNode;
+      this._tail = newNode;
     }
     this._length++;
   }
@@ -136,10 +102,10 @@ export class DoublyLinkedList<E = any> {
     if (!this.tail) return undefined;
     const removedNode = this.tail;
     if (this.head === this.tail) {
-      this.head = null;
-      this.tail = null;
+      this._head = null;
+      this._tail = null;
     } else {
-      this.tail = removedNode.prev;
+      this._tail = removedNode.prev;
       this.tail!.next = null;
     }
     this._length--;
@@ -164,10 +130,10 @@ export class DoublyLinkedList<E = any> {
     if (!this.head) return undefined;
     const removedNode = this.head;
     if (this.head === this.tail) {
-      this.head = null;
-      this.tail = null;
+      this._head = null;
+      this._tail = null;
     } else {
-      this.head = removedNode.next;
+      this._head = removedNode.next;
       this.head!.prev = null;
     }
     this._length--;
@@ -191,12 +157,12 @@ export class DoublyLinkedList<E = any> {
   unshift(value: E): void {
     const newNode = new DoublyLinkedListNode(value);
     if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
+      this._head = newNode;
+      this._tail = newNode;
     } else {
       newNode.next = this.head;
       this.head!.prev = newNode;
-      this.head = newNode;
+      this._head = newNode;
     }
     this._length++;
   }
@@ -338,7 +304,7 @@ export class DoublyLinkedList<E = any> {
       newNode.next = existingNode;
       existingNode.prev = newNode;
       if (existingNode === this.head) {
-        this.head = newNode;
+        this._head = newNode;
       }
       this._length++;
       return true;
@@ -508,7 +474,7 @@ export class DoublyLinkedList<E = any> {
    */
   reverse(): void {
     let current = this.head;
-    [this.head, this.tail] = [this.tail, this.head];
+    [this._head, this._tail] = [this.tail, this.head];
     while (current) {
       const next = current.next;
       [current.prev, current.next] = [current.next, current.prev];
@@ -616,7 +582,7 @@ export class DoublyLinkedList<E = any> {
       newNode.prev = existingNode;
       existingNode.next = newNode;
       if (existingNode === this.tail) {
-        this.tail = newNode;
+        this._tail = newNode;
       }
       this._length++;
       return true;
@@ -628,7 +594,7 @@ export class DoublyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -6,34 +6,17 @@
  * @license MIT License
  */
 export class SinglyLinkedListNode<E = any> {
+  value: E;
+  next: SinglyLinkedListNode<E> | null;
+
   /**
    * The constructor function initializes an instance of a class with a given value and sets the next property to null.
    * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
    * will be stored in the node of a linked list.
    */
   constructor(value: E) {
-    this._value = value;
-    this._next = null;
-  }
-
-  private _value: E;
-
-  get value(): E {
-    return this._value;
-  }
-
-  set value(value: E) {
-    this._value = value;
-  }
-
-  private _next: SinglyLinkedListNode<E> | null;
-
-  get next(): SinglyLinkedListNode<E> | null {
-    return this._next;
-  }
-
-  set next(value: SinglyLinkedListNode<E> | null) {
-    this._next = value;
+    this.value = value;
+    this.next = null;
   }
 }
 
@@ -47,27 +30,19 @@ export class SinglyLinkedList<E = any> {
     this._length = 0;
   }
 
-  private _head: SinglyLinkedListNode<E> | null;
+  protected _head: SinglyLinkedListNode<E> | null;
 
   get head(): SinglyLinkedListNode<E> | null {
     return this._head;
   }
 
-  set head(value: SinglyLinkedListNode<E> | null) {
-    this._head = value;
-  }
-
-  private _tail: SinglyLinkedListNode<E> | null;
+  protected _tail: SinglyLinkedListNode<E> | null;
 
   get tail(): SinglyLinkedListNode<E> | null {
     return this._tail;
   }
 
-  set tail(value: SinglyLinkedListNode<E> | null) {
-    this._tail = value;
-  }
-
-  private _length: number;
+  protected _length: number;
 
   get length(): number {
     return this._length;
@@ -95,11 +70,11 @@ export class SinglyLinkedList<E = any> {
   push(value: E): void {
     const newNode = new SinglyLinkedListNode(value);
     if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
+      this._head = newNode;
+      this._tail = newNode;
     } else {
       this.tail!.next = newNode;
-      this.tail = newNode;
+      this._tail = newNode;
     }
     this._length++;
   }
@@ -123,8 +98,8 @@ export class SinglyLinkedList<E = any> {
     if (!this.head) return undefined;
     if (this.head === this.tail) {
       const value = this.head.value;
-      this.head = null;
-      this.tail = null;
+      this._head = null;
+      this._tail = null;
       this._length--;
       return value;
     }
@@ -135,7 +110,7 @@ export class SinglyLinkedList<E = any> {
     }
     const value = this.tail!.value;
     current.next = null;
-    this.tail = current;
+    this._tail = current;
     this._length--;
     return value;
   }
@@ -157,7 +132,7 @@ export class SinglyLinkedList<E = any> {
   shift(): E | undefined {
     if (!this.head) return undefined;
     const removedNode = this.head;
-    this.head = this.head.next;
+    this._head = this.head.next;
     this._length--;
     return removedNode.value;
   }
@@ -178,11 +153,11 @@ export class SinglyLinkedList<E = any> {
   unshift(value: E): void {
     const newNode = new SinglyLinkedListNode(value);
     if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
+      this._head = newNode;
+      this._tail = newNode;
     } else {
       newNode.next = this.head;
-      this.head = newNode;
+      this._head = newNode;
     }
     this._length++;
   }
@@ -267,14 +242,14 @@ export class SinglyLinkedList<E = any> {
     while (current) {
       if (current.value === value) {
         if (prev === null) {
-          this.head = current.next;
+          this._head = current.next;
           if (current === this.tail) {
-            this.tail = null;
+            this._tail = null;
           }
         } else {
           prev.next = current.next;
           if (current === this.tail) {
-            this.tail = prev;
+            this._tail = prev;
           }
         }
         this._length--;
@@ -365,7 +340,7 @@ export class SinglyLinkedList<E = any> {
       current = next;
     }
 
-    [this.head, this.tail] = [this.tail!, this.head!];
+    [this._head, this._tail] = [this.tail!, this.head!];
   }
 
   /**
@@ -486,7 +461,7 @@ export class SinglyLinkedList<E = any> {
       newNode.next = existingNode.next;
       existingNode.next = newNode;
       if (existingNode === this.tail) {
-        this.tail = newNode;
+        this._tail = newNode;
       }
       this._length++;
       return true;
@@ -590,7 +565,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {