min-heap-typed 1.45.0 → 1.45.1

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

@@ -5,12 +5,15 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BTNKey, TreeMultimapNodeNested, TreeMultimapOptions} from '../../types';
-import {BiTreeDeleteResult, BTNCallback, CP, FamilyPosition, IterationType} from '../../types';
-import {IBinaryTree} from '../../interfaces';
-import {AVLTree, AVLTreeNode} from './avl-tree';
-
-export class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>> extends AVLTreeNode<V, N> {
+import type { BTNKey, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, CP, FamilyPosition, IterationType } from '../../types';
+import { IBinaryTree } from '../../interfaces';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+
+export class TreeMultimapNode<
+  V = any,
+  N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>
+> extends AVLTreeNode<V, N> {
   count: number;
 
   /**
@@ -292,7 +295,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
         if (!parent) {
           if (curr.right !== undefined) this._setRoot(curr.right);
         } else {
-          const {familyPosition: fp} = curr;
+          const { familyPosition: fp } = curr;
           if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
             parent.left = curr.right;
           } else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
@@ -320,7 +323,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
       if (orgCurrent) this._count -= orgCurrent.count;
     }
 
-    deletedResult.push({deleted: orgCurrent, needBalanced});
+    deletedResult.push({ deleted: orgCurrent, needBalanced });
 
     if (needBalanced) {
       this._balancePath(needBalanced);
@@ -396,7 +399,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     srcNode = this.ensureNotKey(srcNode);
     destNode = this.ensureNotKey(destNode);
     if (srcNode && destNode) {
-      const {key, value, count, height} = destNode;
+      const { key, value, count, height } = destNode;
       const tempNode = this.createNode(key, value, count);
       if (tempNode) {
         tempNode.height = height;

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {uuidV4} from '../../utils';
-import {PriorityQueue} from '../priority-queue';
-import type {DijkstraResult, VertexKey} from '../../types';
-import {IGraph} from '../../interfaces';
-import {Queue} from '../queue';
+import { uuidV4 } from '../../utils';
+import { PriorityQueue } from '../priority-queue';
+import type { DijkstraResult, VertexKey } from '../../types';
+import { IGraph } from '../../interfaces';
+import { Queue } from '../queue';
 
 export abstract class AbstractVertex<V = any> {
   key: VertexKey;
@@ -300,11 +300,11 @@ export abstract class AbstractGraph<
       return [];
     }
 
-    const stack: {vertex: VO; path: VO[]}[] = [];
-    stack.push({vertex: vertex1, path: [vertex1]});
+    const stack: { vertex: VO; path: VO[] }[] = [];
+    stack.push({ vertex: vertex1, path: [vertex1] });
 
     while (stack.length > 0) {
-      const {vertex, path} = stack.pop()!;
+      const { vertex, path } = stack.pop()!;
 
       if (vertex === vertex2) {
         paths.push(path);
@@ -315,7 +315,7 @@ export abstract class AbstractGraph<
       for (const neighbor of neighbors) {
         if (!path.includes(neighbor)) {
           const newPath = [...path, neighbor];
-          stack.push({vertex: neighbor, path: newPath});
+          stack.push({ vertex: neighbor, path: newPath });
         }
       }
     }
@@ -514,7 +514,12 @@ export abstract class AbstractGraph<
    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
    * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
    */
-  dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO> {
+  dijkstraWithoutHeap(
+    src: VO | VertexKey,
+    dest?: VO | VertexKey | null,
+    getMinDist?: boolean,
+    genPaths?: boolean
+  ): DijkstraResult<VO> {
     if (getMinDist === undefined) getMinDist = false;
     if (genPaths === undefined) genPaths = false;
 
@@ -586,7 +591,7 @@ export abstract class AbstractGraph<
           if (genPaths) {
             getPaths(destVertex);
           }
-          return {distMap, preMap, seen, paths, minDist, minPath};
+          return { distMap, preMap, seen, paths, minDist, minPath };
         }
         const neighbors = this.getNeighbors(cur);
         for (const neighbor of neighbors) {
@@ -609,18 +614,18 @@ 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);
 
-    return {distMap, preMap, seen, paths, minDist, minPath};
+    return { distMap, preMap, seen, paths, minDist, minPath };
   }
 
   /**
@@ -657,7 +662,12 @@ export abstract class AbstractGraph<
    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
    * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
    */
-  dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO> {
+  dijkstra(
+    src: VO | VertexKey,
+    dest?: VO | VertexKey | null,
+    getMinDist?: boolean,
+    genPaths?: boolean
+  ): DijkstraResult<VO> {
     if (getMinDist === undefined) getMinDist = false;
     if (genPaths === undefined) genPaths = false;
 
@@ -681,8 +691,8 @@ 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});
-    heap.add({key: 0, value: srcVertex});
+    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);
     preMap.set(srcVertex, null);
@@ -723,7 +733,7 @@ export abstract class AbstractGraph<
             if (genPaths) {
               getPaths(destVertex);
             }
-            return {distMap, preMap, seen, paths, minDist, minPath};
+            return { distMap, preMap, seen, paths, minDist, minPath };
           }
           const neighbors = this.getNeighbors(cur);
           for (const neighbor of neighbors) {
@@ -733,7 +743,7 @@ export abstract class AbstractGraph<
                 const distSrcToNeighbor = distMap.get(neighbor);
                 if (distSrcToNeighbor) {
                   if (dist + weight < distSrcToNeighbor) {
-                    heap.add({key: dist + weight, value: neighbor});
+                    heap.add({ key: dist + weight, value: neighbor });
                     preMap.set(neighbor, cur);
                     distMap.set(neighbor, dist + weight);
                   }
@@ -760,7 +770,7 @@ export abstract class AbstractGraph<
       getPaths(minDest);
     }
 
-    return {distMap, preMap, seen, paths, minDist, minPath};
+    return { distMap, preMap, seen, paths, minDist, minPath };
   }
 
   /**
@@ -800,7 +810,7 @@ export abstract class AbstractGraph<
     // TODO
     let hasNegativeCycle: boolean | undefined;
     if (scanNegativeCycle) hasNegativeCycle = false;
-    if (!srcVertex) return {hasNegativeCycle, distMap, preMap, paths, min, minPath};
+    if (!srcVertex) return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
 
     const vertices = this._vertices;
     const numOfVertices = vertices.size;
@@ -872,7 +882,7 @@ export abstract class AbstractGraph<
       }
     }
 
-    return {hasNegativeCycle, distMap, preMap, paths, min, minPath};
+    return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
   }
 
   /**
@@ -913,7 +923,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
    */
-  floydWarshall(): {costs: number[][]; predecessor: (VO | null)[][]} {
+  floydWarshall(): { costs: number[][]; predecessor: (VO | null)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -945,7 +955,7 @@ export abstract class AbstractGraph<
         }
       }
     }
-    return {costs, predecessor};
+    return { costs, predecessor };
   }
 
   /**
@@ -982,7 +992,12 @@ export abstract class AbstractGraph<
    * are arrays of vertices that form cycles within the SCCs.
    * @returns The function `tarjan` returns an object with the following properties:
    */
-  tarjan(needCutVertexes: boolean = false, needBridges: boolean = false, needSCCs: boolean = true, needCycles: boolean = false) {
+  tarjan(
+    needCutVertexes: boolean = false,
+    needBridges: boolean = false,
+    needSCCs: boolean = true,
+    needCycles: boolean = false
+  ) {
     // !! in undirected graph we will not let child visit parent when dfs
     // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
     // !! bridge: low(child) > dfn(cur)
@@ -1081,7 +1096,7 @@ export abstract class AbstractGraph<
       });
     }
 
-    return {dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles};
+    return { dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles };
   }
 
   /**

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
-import type {TopologicalStatus, VertexKey} from '../../types';
-import {IGraph} from '../../interfaces';
+import { arrayRemove } from '../../utils';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import type { TopologicalStatus, VertexKey } from '../../types';
+import { IGraph } from '../../interfaces';
 
 export class DirectedVertex<V = any> extends AbstractVertex<V> {
   /**
@@ -45,7 +45,12 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
-export class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V> = DirectedVertex<V>, EO extends DirectedEdge<E> = DirectedEdge<E>>
+export class DirectedGraph<
+  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> {
   /**

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

@@ -1,5 +1,5 @@
-import {MapGraphCoordinate, VertexKey} from '../../types';
-import {DirectedEdge, DirectedGraph, DirectedVertex} from './directed-graph';
+import { MapGraphCoordinate, VertexKey } from '../../types';
+import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 
 export class MapVertex<V = any> extends DirectedVertex<V> {
   lat: number;
@@ -40,12 +40,12 @@ export class MapEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
-export class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVertex<V>, EO extends MapEdge<E> = MapEdge<E>> extends DirectedGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+export class MapGraph<
+  V = any,
+  E = any,
+  VO extends MapVertex<V> = MapVertex<V>,
+  EO extends MapEdge<E> = MapEdge<E>
+> extends DirectedGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
    * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
-import type {VertexKey} from '../../types';
-import {IGraph} from '../../interfaces';
+import { arrayRemove } from '../../utils';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import type { VertexKey } from '../../types';
+import { IGraph } from '../../interfaces';
 
 export class UndirectedVertex<V = any> extends AbstractVertex<V> {
   /**
@@ -43,11 +43,11 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
 }
 
 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> {
   /**

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

@@ -6,8 +6,8 @@
  * @license MIT License
  */
 
-import {isObjOrFunc, rangeCheck, throwRangeError} from "../../utils";
-import {HashMapLinkedNode, HashMapOptions, IterateDirection} from "../../types";
+import { isObjOrFunc, rangeCheck, throwRangeError } from '../../utils';
+import { HashMapLinkedNode, HashMapOptions, IterateDirection } from '../../types';
 
 /**
  * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
@@ -16,9 +16,8 @@ import {HashMapLinkedNode, HashMapOptions, IterateDirection} from "../../types";
  */
 export class HashMapIterator<K, V> {
   readonly hashMap: HashMap<K, V>;
-
-  protected _node: HashMapLinkedNode<K, V>;
   readonly iterateDirection: IterateDirection;
+  protected _node: HashMapLinkedNode<K, V>;
   protected readonly _sentinel: HashMapLinkedNode<K, V>;
 
   /**
@@ -36,13 +35,16 @@ export class HashMapIterator<K, V> {
    * @returns The constructor does not return anything. It is used to initialize the properties and
    * methods of the object being created.
    */
-  constructor(node: HashMapLinkedNode<K, V>, sentinel: HashMapLinkedNode<K, V>,
-              hashMap: HashMap<K, V>, iterateDirection: IterateDirection = IterateDirection.DEFAULT) {
+  constructor(
+    node: HashMapLinkedNode<K, V>,
+    sentinel: HashMapLinkedNode<K, V>,
+    hashMap: HashMap<K, V>,
+    iterateDirection: IterateDirection = IterateDirection.DEFAULT
+  ) {
     this._node = node;
     this._sentinel = sentinel;
     this.iterateDirection = iterateDirection;
 
-
     if (this.iterateDirection === IterateDirection.DEFAULT) {
       this.prev = function () {
         if (this._node.prev === this._sentinel) {
@@ -87,7 +89,7 @@ export class HashMapIterator<K, V> {
       throwRangeError();
     }
 
-    return new Proxy(<[K, V]><unknown>[], {
+    return new Proxy(<[K, V]>(<unknown>[]), {
       get: (target, prop: '0' | '1') => {
         if (prop === '0') return this._node.key;
         else if (prop === '1') return this._node.value;
@@ -113,7 +115,6 @@ export class HashMapIterator<K, V> {
     return this._node !== this._sentinel;
   }
 
-
   prev() {
     return this;
   }
@@ -124,18 +125,12 @@ export class HashMapIterator<K, V> {
 }
 
 export class HashMap<K = any, V = any> {
+  readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
   protected _nodes: HashMapLinkedNode<K, V>[] = [];
   protected _orgMap: Record<string, HashMapLinkedNode<K, V>> = {};
   protected _head: HashMapLinkedNode<K, V>;
   protected _tail: HashMapLinkedNode<K, V>;
   protected readonly _sentinel: HashMapLinkedNode<K, V>;
-  readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
-
-  protected _size = 0;
-
-  get size() {
-    return this._size;
-  }
 
   /**
    * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
@@ -151,7 +146,85 @@ export class HashMap<K = any, V = any> {
     hashMap.forEach(el => {
       this.set(el[0], el[1]);
     });
+  }
+
+  protected _size = 0;
+
+  get size() {
+    return this._size;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns a new iterator object for a HashMap.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get begin() {
+    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
+   * end values.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get end() {
+    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
+  }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
+   * a HashMap in reverse order.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get reverseBegin() {
+    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
+   * HashMap in reverse order.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get reverseEnd() {
+    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns the key-value pair at the front of a data structure.
+   * @returns The front element of the data structure, represented as a tuple with a key (K) and a
+   * value (V).
+   */
+  get front() {
+    if (this._size === 0) return;
+    return <[K, V]>[this._head.key, this._head.value];
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns the key-value pair at the end of a data structure.
+   * @returns The method is returning an array containing the key-value pair of the tail element in the
+   * data structure.
+   */
+  get back() {
+    if (this._size === 0) return;
+    return <[K, V]>[this._tail.key, this._tail.value];
   }
 
   /**
@@ -170,7 +243,7 @@ export class HashMap<K = any, V = any> {
   set(key: K, value?: V, isObjectKey: boolean = isObjOrFunc(key)) {
     let newTail;
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       if (index !== undefined) {
         this._nodes[<number>index].value = <V>value;
         return this._size;
@@ -187,12 +260,12 @@ export class HashMap<K = any, V = any> {
       };
       this._nodes.push(newTail);
     } else {
-      const node = this._orgMap[<string><unknown>key];
+      const node = this._orgMap[<string>(<unknown>key)];
       if (node) {
         node.value = <V>value;
         return this._size;
       }
-      this._orgMap[<string><unknown>key] = newTail = {
+      this._orgMap[<string>(<unknown>key)] = newTail = {
         key: key,
         value: <V>value,
         prev: this._tail,
@@ -228,10 +301,10 @@ export class HashMap<K = any, V = any> {
    */
   get(key: K, isObjectKey: boolean = isObjOrFunc(key)) {
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       return index !== undefined ? this._nodes[index].value : undefined;
     }
-    const node = this._orgMap[<string><unknown>key];
+    const node = this._orgMap[<string>(<unknown>key)];
     return node ? node.value : undefined;
   }
 
@@ -269,16 +342,16 @@ export class HashMap<K = any, V = any> {
    * @returns a new instance of the `HashMapIterator` class.
    */
   getIterator(key: K, isObjectKey?: boolean) {
-    let node: HashMapLinkedNode<K, V>
+    let node: HashMapLinkedNode<K, V>;
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       if (index === undefined) {
-        node = this._sentinel
+        node = this._sentinel;
       } else {
         node = this._nodes[index];
       }
     } else {
-      node = this._orgMap[<string><unknown>key] || this._sentinel;
+      node = this._orgMap[<string>(<unknown>key)] || this._sentinel;
     }
     return new HashMapIterator<K, V>(node, this._sentinel, this);
   }
@@ -299,15 +372,15 @@ export class HashMap<K = any, V = any> {
   delete(key: K, isObjectKey: boolean = isObjOrFunc(key)) {
     let node;
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       if (index === undefined) return false;
-      delete (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      delete (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       node = this._nodes[index];
       delete this._nodes[index];
     } else {
-      node = this._orgMap[<string><unknown>key];
+      node = this._orgMap[<string>(<unknown>key)];
       if (node === undefined) return false;
-      delete this._orgMap[<string><unknown>key];
+      delete this._orgMap[<string>(<unknown>key)];
     }
     this._deleteNode(node);
     return true;
@@ -362,79 +435,6 @@ export class HashMap<K = any, V = any> {
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new iterator object for a HashMap.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get begin() {
-    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-   * end values.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get end() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-   * a HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseBegin() {
-    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-   * HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseEnd() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns the key-value pair at the front of a data structure.
-   * @returns The front element of the data structure, represented as a tuple with a key (K) and a
-   * value (V).
-   */
-  get front() {
-    if (this._size === 0) return;
-    return <[K, V]>[this._head.key, this._head.value];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns the key-value pair at the end of a data structure.
-   * @returns The method is returning an array containing the key-value pair of the tail element in the
-   * data structure.
-   */
-  get back() {
-    if (this._size === 0) return;
-    return <[K, V]>[this._tail.key, this._tail.value];
-  }
-
   /**
    * Time Complexity: O(n), where n is the number of elements in the HashMap.
    * Space Complexity: O(1)
@@ -478,7 +478,7 @@ export class HashMap<K = any, V = any> {
    * and next nodes in the list.
    */
   protected _deleteNode(node: HashMapLinkedNode<K, V>) {
-    const {prev, next} = node;
+    const { prev, next } = node;
     prev.next = next;
     next.prev = prev;
     if (node === this._head) {

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

@@ -18,7 +18,7 @@ export class HashTableNode<K, V> {
   }
 }
 
-import {HashFunction} from '../../types';
+import { HashFunction } from '../../types';
 
 export class HashTable<K, V> {
   protected static readonly DEFAULT_CAPACITY = 16;

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