min-heap-typed 1.39.6 → 1.40.0

package/src/data-structures/graph/abstract-graph.ts

@@ -12,6 +12,9 @@ import {IGraph} from '../../interfaces';
 import {Queue} from '../queue';
 
 export abstract class AbstractVertex<V = any> {
+  key: VertexKey;
+  value: V | undefined;
+
   /**
    * The function is a protected constructor that takes an key and an optional value as parameters.
    * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
@@ -20,32 +23,16 @@ export abstract class AbstractVertex<V = any> {
    * vertex. If no value is provided, it will be set to undefined.
    */
   protected constructor(key: VertexKey, value?: V) {
-    this._key = key;
-    this._value = value;
-  }
-
-  private _key: VertexKey;
-
-  get key(): VertexKey {
-    return this._key;
-  }
-
-  set key(v: VertexKey) {
-    this._key = v;
-  }
-
-  private _value: V | undefined;
-
-  get value(): V | undefined {
-    return this._value;
+    this.key = key;
+    this.value = value;
   }
 
-  set value(value: V | undefined) {
-    this._value = value;
-  }
 }
 
 export abstract class AbstractEdge<E = any> {
+  value: E | undefined;
+  weight: number;
+
   /**
    * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
    * object.
@@ -56,31 +43,11 @@ export abstract class AbstractEdge<E = any> {
    * meaning it can be omitted when creating an instance of the class.
    */
   protected constructor(weight?: number, value?: E) {
-    this._weight = weight !== undefined ? weight : 1;
-    this._value = value;
+    this.weight = weight !== undefined ? weight : 1;
+    this.value = value;
     this._hashCode = uuidV4();
   }
 
-  private _value: E | undefined;
-
-  get value(): E | undefined {
-    return this._value;
-  }
-
-  set value(value: E | undefined) {
-    this._value = value;
-  }
-
-  private _weight: number;
-
-  get weight(): number {
-    return this._weight;
-  }
-
-  set weight(v: number) {
-    this._weight = v;
-  }
-
   protected _hashCode: string;
 
   get hashCode(): string {
@@ -91,15 +58,6 @@ export abstract class AbstractEdge<E = any> {
    * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
    * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
    */
-
-  /**
-   * The function sets the value of the _hashCode property to the provided string.
-   * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-   * "_hashCode" property.
-   */
-  protected _setHashCode(v: string) {
-    this._hashCode = v;
-  }
 }
 
 export abstract class AbstractGraph<
@@ -107,9 +65,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO>
-{
-  private _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
+> implements IGraph<V, E, VO, EO> {
+  protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
     return this._vertices;
@@ -556,14 +513,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-      distMap.forEach((d, v) => {
-        if (v !== srcVertex) {
-          if (d < minDist) {
-            minDist = d;
-            if (genPaths) minDest = v;
-          }
+    distMap.forEach((d, v) => {
+      if (v !== srcVertex) {
+        if (d < minDist) {
+          minDist = d;
+          if (genPaths) minDest = v;
         }
-      });
+      }
+    });
 
     genPaths && getPaths(minDest);
 
@@ -625,7 +582,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{key: number; value: VO}>({comparator: (a, b) => a.key - b.key});
+    const heap = new PriorityQueue<{ key: number; value: VO }>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, value: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -854,7 +811,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): {costs: number[][]; predecessor: (VO | null)[][]} {
+  floyd(): { costs: number[][]; predecessor: (VO | null)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -1040,7 +997,4 @@ export abstract class AbstractGraph<
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
 
-  protected _setVertices(value: Map<VertexKey, VO>) {
-    this._vertices = value;
-  }
 }

package/src/data-structures/graph/directed-graph.ts

@@ -24,6 +24,9 @@ export class DirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export class DirectedEdge<E = any> extends AbstractEdge<E> {
+  src: VertexKey;
+  dest: VertexKey;
+
   /**
    * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
    * and value.
@@ -37,40 +40,19 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
    */
   constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this._src = src;
-    this._dest = dest;
-  }
-
-  private _src: VertexKey;
-
-  get src(): VertexKey {
-    return this._src;
-  }
-
-  set src(v: VertexKey) {
-    this._src = v;
-  }
-
-  private _dest: VertexKey;
-
-  get dest(): VertexKey {
-    return this._dest;
-  }
-
-  set dest(v: VertexKey) {
-    this._dest = v;
+    this.src = src;
+    this.dest = dest;
   }
 }
 
 export class DirectedGraph<
-    V = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends DirectedVertex<V> = DirectedVertex<V>,
+  EO extends DirectedEdge<E> = DirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes an instance of a class.
    */
@@ -78,13 +60,13 @@ export class DirectedGraph<
     super();
   }
 
-  private _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
+  protected _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get outEdgeMap(): Map<VO, EO[]> {
     return this._outEdgeMap;
   }
 
-  private _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
+  protected _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get inEdgeMap(): Map<VO, EO[]> {
     return this._inEdgeMap;
@@ -464,12 +446,4 @@ export class DirectedGraph<
       return false;
     }
   }
-
-  protected _setOutEdgeMap(value: Map<VO, EO[]>) {
-    this._outEdgeMap = value;
-  }
-
-  protected _setInEdgeMap(value: Map<VO, EO[]>) {
-    this._inEdgeMap = value;
-  }
 }

package/src/data-structures/graph/map-graph.ts

@@ -2,6 +2,9 @@ import {MapGraphCoordinate, VertexKey} from '../../types';
 import {DirectedEdge, DirectedGraph, DirectedVertex} from './directed-graph';
 
 export class MapVertex<V = any> extends DirectedVertex<V> {
+  lat: number;
+  long: number;
+
   /**
    * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
    * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
@@ -16,28 +19,8 @@ export class MapVertex<V = any> extends DirectedVertex<V> {
    */
   constructor(key: VertexKey, value: V, lat: number, long: number) {
     super(key, value);
-    this._lat = lat;
-    this._long = long;
-  }
-
-  private _lat: number;
-
-  get lat(): number {
-    return this._lat;
-  }
-
-  set lat(value: number) {
-    this._lat = value;
-  }
-
-  private _long: number;
-
-  get long(): number {
-    return this._long;
-  }
-
-  set long(value: number) {
-    this._long = value;
+    this.lat = lat;
+    this.long = long;
   }
 }
 
@@ -78,26 +61,18 @@ export class MapGraph<
     this._bottomRight = bottomRight;
   }
 
-  private _origin: MapGraphCoordinate = [0, 0];
+  protected _origin: MapGraphCoordinate = [0, 0];
 
   get origin(): MapGraphCoordinate {
     return this._origin;
   }
 
-  set origin(value: MapGraphCoordinate) {
-    this._origin = value;
-  }
-
-  private _bottomRight: MapGraphCoordinate | undefined;
+  protected _bottomRight: MapGraphCoordinate | undefined;
 
   get bottomRight(): MapGraphCoordinate | undefined {
     return this._bottomRight;
   }
 
-  set bottomRight(value: MapGraphCoordinate | undefined) {
-    this._bottomRight = value;
-  }
-
   /**
    * The function creates a new vertex with the given key, value, latitude, and longitude.
    * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could

package/src/data-structures/graph/undirected-graph.ts

@@ -24,6 +24,8 @@ export class UndirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export class UndirectedEdge<E = number> extends AbstractEdge<E> {
+  vertices: [VertexKey, VertexKey];
+
   /**
    * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
    * value.
@@ -36,29 +38,18 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
    */
   constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this._vertices = [v1, v2];
-  }
-
-  private _vertices: [VertexKey, VertexKey];
-
-  get vertices() {
-    return this._vertices;
-  }
-
-  set vertices(v: [VertexKey, VertexKey]) {
-    this._vertices = v;
+    this.vertices = [v1, v2];
   }
 }
 
 export class UndirectedGraph<
-    V = any,
-    E = any,
-    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-    EO extends UndirectedEdge<E> = UndirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+  EO extends UndirectedEdge<E> = UndirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor initializes a new Map object to store edges.
    */
@@ -265,12 +256,4 @@ export class UndirectedGraph<
     }
     return true;
   }
-
-  /**
-   * The function sets the edges of a graph.
-   * @param v - A map where the keys are of type VO and the values are arrays of type EO.
-   */
-  protected _setEdges(v: Map<VO, EO[]>) {
-    this._edges = v;
-  }
 }

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

@@ -60,8 +60,4 @@ export class CoordinateMap<V> extends Map<any, V> {
   override delete(key: number[]) {
     return super.delete(key.join(this._joint));
   }
-
-  protected _setJoint(v: string) {
-    this._joint = v;
-  }
 }

package/src/data-structures/hash/coordinate-set.ts

@@ -49,8 +49,4 @@ export class CoordinateSet extends Set<any> {
   override delete(value: number[]) {
     return super.delete(value.join(this._joint));
   }
-
-  protected _setJoint(v: string) {
-    this._joint = v;
-  }
 }

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

@@ -38,66 +38,42 @@ export class HashMap<K, V> {
       });
   }
 
-  private _initialCapacity: number;
+  protected _initialCapacity: number;
 
   get initialCapacity(): number {
     return this._initialCapacity;
   }
 
-  set initialCapacity(value: number) {
-    this._initialCapacity = value;
-  }
-
-  private _loadFactor: number;
+  protected _loadFactor: number;
 
   get loadFactor(): number {
     return this._loadFactor;
   }
 
-  set loadFactor(value: number) {
-    this._loadFactor = value;
-  }
-
-  private _capacityMultiplier: number;
+  protected _capacityMultiplier: number;
 
   get capacityMultiplier(): number {
     return this._capacityMultiplier;
   }
 
-  set capacityMultiplier(value: number) {
-    this._capacityMultiplier = value;
-  }
-
-  private _size: number;
+  protected _size: number;
 
   get size(): number {
     return this._size;
   }
 
-  set size(value: number) {
-    this._size = value;
-  }
-
-  private _table: Array<Array<[K, V]>>;
+  protected _table: Array<Array<[K, V]>>;
 
   get table(): Array<Array<[K, V]>> {
     return this._table;
   }
 
-  set table(value: Array<Array<[K, V]>>) {
-    this._table = value;
-  }
-
-  private _hashFn: HashFunction<K>;
+  protected _hashFn: HashFunction<K>;
 
   get hashFn(): HashFunction<K> {
     return this._hashFn;
   }
 
-  set hashFn(value: HashFunction<K>) {
-    this._hashFn = value;
-  }
-
   set(key: K, value: V): void {
     const loadFactor = this.size / this.table.length;
     if (loadFactor >= this.loadFactor) {
@@ -118,7 +94,7 @@ export class HashMap<K, V> {
     }
 
     this.table[index].push([key, value]);
-    this.size++;
+    this._size++;
   }
 
   get(key: K): V | undefined {
@@ -145,7 +121,7 @@ export class HashMap<K, V> {
     for (let i = 0; i < this.table[index].length; i++) {
       if (this.table[index][i][0] === key) {
         this.table[index].splice(i, 1);
-        this.size--;
+        this._size--;
 
         // Check if the table needs to be resized down
         const loadFactor = this.size / this.table.length;
@@ -157,7 +133,7 @@ export class HashMap<K, V> {
     }
   }
 
-  *entries(): IterableIterator<[K, V]> {
+  * entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {
@@ -172,15 +148,15 @@ export class HashMap<K, V> {
   }
 
   clear(): void {
-    this.size = 0;
-    this.table = new Array(this.initialCapacity);
+    this._size = 0;
+    this._table = new Array(this.initialCapacity);
   }
 
   isEmpty(): boolean {
     return this.size === 0;
   }
 
-  private _hash(key: K): number {
+  protected _hash(key: K): number {
     return this._hashFn(key);
   }
 
@@ -190,7 +166,7 @@ export class HashMap<K, V> {
    * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
    * the number of buckets that the new table should have.
    */
-  private resizeTable(newCapacity: number): void {
+  protected resizeTable(newCapacity: number): void {
     const newTable = new Array(newCapacity);
     for (const bucket of this._table) {
       // Note that this is this._table

package/src/data-structures/hash/hash-table.ts

@@ -21,8 +21,8 @@ export class HashTableNode<K, V> {
 import {HashFunction} from '../../types';
 
 export class HashTable<K, V> {
-  private static readonly DEFAULT_CAPACITY = 16;
-  private static readonly LOAD_FACTOR = 0.75;
+  protected static readonly DEFAULT_CAPACITY = 16;
+  protected static readonly LOAD_FACTOR = 0.75;
 
   constructor(capacity: number = HashTable.DEFAULT_CAPACITY, hashFn?: HashFunction<K>) {
     this._hashFn = hashFn || this._defaultHashFn;
@@ -31,42 +31,30 @@ export class HashTable<K, V> {
     this._buckets = new Array<HashTableNode<K, V> | null>(this._capacity).fill(null);
   }
 
-  private _capacity: number;
+  protected _capacity: number;
 
   get capacity(): number {
     return this._capacity;
   }
 
-  set capacity(value: number) {
-    this._capacity = value;
-  }
-
-  private _size: number;
+  protected _size: number;
 
   get size(): number {
     return this._size;
   }
 
-  private _buckets: Array<HashTableNode<K, V> | null>;
+  protected _buckets: Array<HashTableNode<K, V> | null>;
 
   get buckets(): Array<HashTableNode<K, V> | null> {
     return this._buckets;
   }
 
-  set buckets(value: Array<HashTableNode<K, V> | null>) {
-    this._buckets = value;
-  }
-
-  private _hashFn: HashFunction<K>;
+  protected _hashFn: HashFunction<K>;
 
   get hashFn(): HashFunction<K> {
     return this._hashFn;
   }
 
-  set hashFn(value: HashFunction<K>) {
-    this._hashFn = value;
-  }
-
   /**
    * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
    * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash

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

@@ -1 +1,2 @@
-export class TreeMap {}
+export class TreeMap {
+}

package/src/data-structures/hash/tree-set.ts

@@ -1 +1,2 @@
-export class TreeSet {}
+export class TreeSet {
+}