data-structure-typed 1.34.7 → 1.34.9

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

@@ -7,19 +7,19 @@
  */
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
-import type {VertexId} from '../../types';
+import type {VertexKey} from '../../types';
 import {IUNDirectedGraph} from '../../interfaces';
 
 export class UndirectedVertex<V = any> extends AbstractVertex<V> {
   /**
    * The constructor function initializes a vertex with an optional value.
-   * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
+   * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
    * used to uniquely identify the vertex within a graph or network.
    * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
    * vertex. If no value is provided, the vertex will be initialized with a default value.
    */
-  constructor(id: VertexId, val?: V) {
-    super(id, val);
+  constructor(key: VertexKey, val?: V) {
+    super(key, val);
   }
 }
 
@@ -27,25 +27,25 @@ export class UndirectedEdge<V = number> extends AbstractEdge<V> {
   /**
    * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
    * value.
-   * @param {VertexId} v1 - The first vertex ID of the edge.
-   * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+   * @param {VertexKey} v1 - The first vertex ID of the edge.
+   * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
    * graph edge.
    * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
    * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
    * with the edge.
    */
-  constructor(v1: VertexId, v2: VertexId, weight?: number, val?: V) {
+  constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: V) {
     super(weight, val);
     this._vertices = [v1, v2];
   }
 
-  private _vertices: [VertexId, VertexId];
+  private _vertices: [VertexKey, VertexKey];
 
   get vertices() {
     return this._vertices;
   }
 
-  set vertices(v: [VertexId, VertexId]) {
+  set vertices(v: [VertexKey, VertexKey]) {
     this._vertices = v;
   }
 }
@@ -73,40 +73,40 @@ export class UndirectedGraph<
 
   /**
    * The function creates a new vertex with an optional value and returns it.
-   * @param {VertexId} id - The `id` parameter is the unique identifier for the vertex. It is used to distinguish one
+   * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
    * vertex from another in the graph.
    * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
-   * it will be used as the value of the vertex. If no value is provided, the `id` parameter will be used as the value of
+   * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
    * the vertex.
    * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
    */
-  override createVertex(id: VertexId, val?: V['val']): V {
-    return new UndirectedVertex(id, val ?? id) as V;
+  override createVertex(key: VertexKey, val?: V['val']): V {
+    return new UndirectedVertex(key, val ?? key) as V;
   }
 
   /**
    * The function creates an undirected edge between two vertices with an optional weight and value.
-   * @param {VertexId} v1 - The parameter `v1` represents the first vertex of the edge.
-   * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge.
+   * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
+   * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of the edge.
    * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
    * no weight is provided, it defaults to 1.
    * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
    * is used to store additional information or data associated with the edge.
    * @returns a new instance of the `UndirectedEdge` class, which is casted as type `E`.
    */
-  override createEdge(v1: VertexId, v2: VertexId, weight?: number, val?: E['val']): E {
+  override createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: E['val']): E {
     return new UndirectedEdge(v1, v2, weight ?? 1, val) as E;
   }
 
   /**
    * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-   * @param {V | null | VertexId} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
-   * object), `null`, or `VertexId` (a string or number representing the ID of a vertex).
-   * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
-   * object), `null`, or `VertexId` (vertex ID).
+   * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+   * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
+   * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+   * object), `null`, or `VertexKey` (vertex ID).
    * @returns an edge (E) or null.
    */
-  getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null {
+  getEdge(v1: V | null | VertexKey, v2: V | null | VertexKey): E | null {
     let edges: E[] | undefined = [];
 
     if (v1 !== null && v2 !== null) {
@@ -114,7 +114,7 @@ export class UndirectedGraph<
       const vertex2: V | null = this._getVertex(v2);
 
       if (vertex1 && vertex2) {
-        edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.id));
+        edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.key));
       }
     }
 
@@ -123,12 +123,12 @@ export class UndirectedGraph<
 
   /**
    * The function removes an edge between two vertices in a graph and returns the removed edge.
-   * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
-   * @param {V | VertexId} v2 - V | VertexId - This parameter can be either a vertex object (V) or a vertex ID
-   * (VertexId). It represents the second vertex of the edge that needs to be removed.
+   * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
+   * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+   * (VertexKey). It represents the second vertex of the edge that needs to be removed.
    * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
    */
-  removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null {
+  removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
     const vertex1: V | null = this._getVertex(v1);
     const vertex2: V | null = this._getVertex(v2);
 
@@ -139,11 +139,11 @@ export class UndirectedGraph<
     const v1Edges = this._edges.get(vertex1);
     let removed: E | null = null;
     if (v1Edges) {
-      removed = arrayRemove<E>(v1Edges, (e: E) => e.vertices.includes(vertex2.id))[0] || null;
+      removed = arrayRemove<E>(v1Edges, (e: E) => e.vertices.includes(vertex2.key))[0] || null;
     }
     const v2Edges = this._edges.get(vertex2);
     if (v2Edges) {
-      arrayRemove<E>(v2Edges, (e: E) => e.vertices.includes(vertex1.id));
+      arrayRemove<E>(v2Edges, (e: E) => e.vertices.includes(vertex1.key));
     }
     return removed;
   }
@@ -160,12 +160,12 @@ export class UndirectedGraph<
   /**
    * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
    * vertex.
-   * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+   * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
    * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
    * edges connected to that vertex.
    */
-  degreeOf(vertexOrId: VertexId | V): number {
-    const vertex = this._getVertex(vertexOrId);
+  degreeOf(vertexOrKey: VertexKey | V): number {
+    const vertex = this._getVertex(vertexOrKey);
     if (vertex) {
       return this._edges.get(vertex)?.length || 0;
     } else {
@@ -175,12 +175,12 @@ export class UndirectedGraph<
 
   /**
    * The function returns the edges of a given vertex or vertex ID.
-   * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`. A `VertexId` is a
+   * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
    * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
    * @returns an array of edges.
    */
-  edgesOf(vertexOrId: VertexId | V): E[] {
-    const vertex = this._getVertex(vertexOrId);
+  edgesOf(vertexOrKey: VertexKey | V): E[] {
+    const vertex = this._getVertex(vertexOrKey);
     if (vertex) {
       return this._edges.get(vertex) || [];
     } else {
@@ -204,17 +204,17 @@ export class UndirectedGraph<
 
   /**
    * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-   * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-   * (`VertexId`).
+   * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+   * (`VertexKey`).
    * @returns an array of vertices (V[]).
    */
-  getNeighbors(vertexOrId: V | VertexId): V[] {
+  getNeighbors(vertexOrKey: V | VertexKey): V[] {
     const neighbors: V[] = [];
-    const vertex = this._getVertex(vertexOrId);
+    const vertex = this._getVertex(vertexOrKey);
     if (vertex) {
       const neighborEdges = this.edgesOf(vertex);
       for (const edge of neighborEdges) {
-        const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.id)[0]);
+        const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.key)[0]);
         if (neighbor) {
           neighbors.push(neighbor);
         }

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

@@ -195,13 +195,13 @@ export class PriorityQueue<E = any> {
   }
 
   /**
-   * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
+   * The dfs function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
    * based on the specified traversal order.
    * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
-   * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
+   * the nodes should be visited during the Depth-First Search (dfs) traversal. It can have one of the following values:
    * @returns an array of type `(E | null)[]`.
    */
-  DFS(dfsMode: PriorityQueueDFSOrderPattern): (E | null)[] {
+  dfs(dfsMode: PriorityQueueDFSOrderPattern): (E | null)[] {
     const visitedNode: (E | null)[] = [];
 
     const traverse = (cur: number) => {

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

@@ -1,18 +1,18 @@
 export class TreeNode<V = any> {
-  constructor(id: string, value?: V, children?: TreeNode<V>[]) {
-    this._id = id;
+  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
+    this._key = key;
     this._value = value || undefined;
     this._children = children || [];
   }
 
-  private _id: string;
+  private _key: string;
 
-  get id(): string {
-    return this._id;
+  get key(): string {
+    return this._key;
   }
 
-  set id(value: string) {
-    this._id = value;
+  set key(value: string) {
+    this._key = value;
   }
 
   private _value?: V | undefined;

package/src/interfaces/abstract-binary-tree.ts

@@ -2,7 +2,7 @@ import {
   AbstractBinaryTreeNodeProperties,
   AbstractBinaryTreeNodeProperty,
   BinaryTreeDeletedResult,
-  BinaryTreeNodeId,
+  BinaryTreeNodeKey,
   BinaryTreeNodePropertyName,
   DFSOrderPattern,
   FamilyPosition,
@@ -12,13 +12,9 @@ import {
 import {AbstractBinaryTreeNode} from '../data-structures';
 
 export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
-  get id(): BinaryTreeNodeId;
+  key: BinaryTreeNodeKey;
 
-  set id(v: BinaryTreeNodeId);
-
-  get val(): T | undefined;
-
-  set val(v: T | undefined);
+  val: T | undefined;
 
   get left(): NEIGHBOR | null | undefined;
 
@@ -28,23 +24,17 @@ export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTree
 
   set right(v: NEIGHBOR | null | undefined);
 
-  get parent(): NEIGHBOR | null | undefined;
-
-  set parent(v: NEIGHBOR | null | undefined);
+  parent: NEIGHBOR | null | undefined;
 
   get familyPosition(): FamilyPosition;
-
-  get height(): number;
-
-  set height(v: number);
 }
 
 export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
-  createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
+  createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N | null;
 
   get loopType(): LoopType;
 
-  get visitedId(): BinaryTreeNodeId[];
+  get visitedKey(): BinaryTreeNodeKey[];
 
   get visitedVal(): Array<N['val']>;
 
@@ -60,13 +50,13 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   isEmpty(): boolean;
 
-  add(id: BinaryTreeNodeId | N, val?: N['val']): N | null | undefined;
+  add(key: BinaryTreeNodeKey | N, val?: N['val']): N | null | undefined;
 
-  addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+  addMany(keysOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N['val'][]): (N | null | undefined)[];
 
-  fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
+  refill(keysOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N[] | Array<N['val']>): boolean;
 
-  remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+  remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
 
   getDepth(node: N): number;
 
@@ -76,11 +66,11 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   isPerfectlyBalanced(beginRoot?: N | null): boolean;
 
-  getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+  getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
 
-  has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
+  has(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): boolean;
 
-  get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+  get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
 
   getPathToRoot(node: N): N[];
 
@@ -108,48 +98,45 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
 
-  BFS(): BinaryTreeNodeId[];
+  bfs(): BinaryTreeNodeKey[];
 
-  BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+  bfs(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
 
-  BFS(nodeOrPropertyName: 'val'): N['val'][];
+  bfs(nodeOrPropertyName: 'val'): N['val'][];
 
-  BFS(nodeOrPropertyName: 'node'): N[];
+  bfs(nodeOrPropertyName: 'node'): N[];
 
-  BFS(nodeOrPropertyName: 'count'): number[];
+  bfs(nodeOrPropertyName: 'count'): number[];
 
-  BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+  bfs(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
-  DFS(): BinaryTreeNodeId[];
+  dfs(): BinaryTreeNodeKey[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
 
-  DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+  dfs(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
-  DFSIterative(): BinaryTreeNodeId[];
+  dfsIterative(): BinaryTreeNodeKey[];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+  dfsIterative(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+  dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+  dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N['val'][];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+  dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
 
-  DFSIterative(
-    pattern?: 'in' | 'pre' | 'post',
-    nodeOrPropertyName?: NodeOrPropertyName
-  ): AbstractBinaryTreeNodeProperties<N>;
+  dfsIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
-  levelIterative(node: N | null): BinaryTreeNodeId[];
+  levelIterative(node: N | null): BinaryTreeNodeKey[];
 
-  levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+  levelIterative(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
 
   levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
 
@@ -159,9 +146,9 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   levelIterative(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
-  listLevels(node: N | null): BinaryTreeNodeId[][];
+  listLevels(node: N | null): BinaryTreeNodeKey[][];
 
-  listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+  listLevels(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[][];
 
   listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
 
@@ -173,9 +160,9 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   getPredecessor(node: N): N;
 
-  morris(): BinaryTreeNodeId[];
+  morris(): BinaryTreeNodeKey[];
 
-  morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+  morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
 
   morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
 

package/src/interfaces/abstract-graph.ts

@@ -1,31 +1,31 @@
-import {VertexId} from '../types';
+import {VertexKey} from '../types';
 
 export interface IAbstractGraph<V, E> {
-  hasVertex(vertexOrId: V | VertexId): boolean;
+  hasVertex(vertexOrKey: V | VertexKey): boolean;
 
-  addVertex(id: VertexId, val?: V): boolean;
+  addVertex(key: VertexKey, val?: V): boolean;
 
-  removeVertex(vertexOrId: V | VertexId): boolean;
+  removeVertex(vertexOrKey: V | VertexKey): boolean;
 
-  removeAllVertices(vertices: V[] | VertexId[]): boolean;
+  removeAllVertices(vertices: V[] | VertexKey[]): boolean;
 
-  degreeOf(vertexOrId: V | VertexId): number;
+  degreeOf(vertexOrKey: V | VertexKey): number;
 
-  edgesOf(vertexOrId: V | VertexId): E[];
+  edgesOf(vertexOrKey: V | VertexKey): E[];
 
-  hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
+  hasEdge(src: V | VertexKey, dest: V | VertexKey): boolean;
 
-  getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+  getEdge(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
 
   edgeSet(): E[];
 
-  addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
+  addEdge(src: V | VertexKey, dest: V | VertexKey, weight: number, val: E): boolean;
 
   removeEdge(edge: E): E | null;
 
-  setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
+  setEdgeWeight(srcOrKey: V | VertexKey, destOrKey: V | VertexKey, weight: number): boolean;
 
-  getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
+  getMinPathBetween(v1: V | VertexKey, v2: V | VertexKey, isWeight?: boolean): V[] | null;
 
-  getNeighbors(vertexOrId: V | VertexId): V[];
+  getNeighbors(vertexOrKey: V | VertexKey): V[];
 }

package/src/interfaces/avl-tree.ts

@@ -1,13 +1,15 @@
 import {AVLTreeNode} from '../data-structures';
 import {IBST, IBSTNode} from './bst';
-import {BinaryTreeDeletedResult, BinaryTreeNodeId} from '../types';
+import {BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../types';
 
-export type IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
+export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+  height: number;
+}
 
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
-  add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
+  add(key: BinaryTreeNodeKey, val?: N['val'] | null): N | null | undefined;
 
-  remove(id: BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
+  remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
 
   // _balanceFactor(node: N): number
   //

package/src/interfaces/bst.ts

@@ -1,25 +1,25 @@
 import {BSTNode} from '../data-structures';
 import {IBinaryTree, IBinaryTreeNode} from './binary-tree';
-import {BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName} from '../types';
+import {BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName} from '../types';
 
-export type IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> = IBinaryTreeNode<T, NEIGHBOR>;
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {}
 
 export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
-  createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+  createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
 
-  add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined;
+  add(key: BinaryTreeNodeKey, val?: N['val'] | null, count?: number): N | null | undefined;
 
-  get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+  get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
 
-  lastKey(): BinaryTreeNodeId;
+  lastKey(): BinaryTreeNodeKey;
 
-  remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+  remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
 
-  getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+  getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
 
   // --- start additional functions
 
-  lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+  lesserSum(key: BinaryTreeNodeKey, propertyName?: BinaryTreeNodePropertyName): number;
 
   allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
 

package/src/interfaces/directed-graph.ts

@@ -1,4 +1,4 @@
-import {VertexId} from '../types';
+import {VertexKey} from '../types';
 import {IAbstractGraph} from './abstract-graph';
 
 export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
@@ -6,15 +6,15 @@ export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
 
   outgoingEdgesOf(vertex: V): E[];
 
-  inDegreeOf(vertexOrId: V | VertexId): number;
+  inDegreeOf(vertexOrKey: V | VertexKey): number;
 
-  outDegreeOf(vertexOrId: V | VertexId): number;
+  outDegreeOf(vertexOrKey: V | VertexKey): number;
 
   getEdgeSrc(e: E): V | null;
 
   getEdgeDest(e: E): V | null;
 
-  removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+  removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
 
-  removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
+  removeEdgesBetween(v1: V | VertexKey, v2: V | VertexKey): E[];
 }

package/src/interfaces/rb-tree.ts

@@ -1,9 +1,9 @@
 import {RBTreeNode} from '../data-structures';
 import {IBST, IBSTNode} from './bst';
-import {BinaryTreeNodeId} from '../types';
+import {BinaryTreeNodeKey} from '../types';
 
 export type IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
 
 export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
-  createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+  createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
 }

package/src/interfaces/undirected-graph.ts

@@ -1,6 +1,6 @@
-import {VertexId} from '../types';
+import {VertexKey} from '../types';
 import {IAbstractGraph} from './abstract-graph';
 
 export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
-  removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+  removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null;
 }

package/src/types/data-structures/abstract-binary-tree.ts

@@ -12,7 +12,6 @@ export enum LoopType {
   RECURSIVE = 'RECURSIVE'
 }
 
-/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 export enum FamilyPosition {
   ROOT = 'ROOT',
   LEFT = 'LEFT',
@@ -23,13 +22,13 @@ export enum FamilyPosition {
   MAL_NODE = 'MAL_NODE'
 }
 
-export type BinaryTreeNodePropertyName = 'id' | 'val';
+export type BinaryTreeNodePropertyName = 'key' | 'val';
 
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 
 export type DFSOrderPattern = 'in' | 'pre' | 'post';
 
-export type BinaryTreeNodeId = number;
+export type BinaryTreeNodeKey = number;
 
 export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
 
@@ -37,7 +36,7 @@ export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['v
   | N['val']
   | N
   | number
-  | BinaryTreeNodeId;
+  | BinaryTreeNodeKey;
 
 
 export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> =

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

@@ -1,5 +1,5 @@
-export type VertexId = string | number;
-export type EdgeId = string;
+export type VertexKey = string | number;
+export type EdgeKey = string;
 export type DijkstraResult<V> = {
   distMap: Map<V, number>;
   distPaths?: Map<V, V[]>;

package/src/types/data-structures/bst.ts

@@ -1,8 +1,8 @@
 import {BSTNode} from '../../data-structures/binary-tree';
 import type {BinaryTreeOptions} from './binary-tree';
-import {BinaryTreeNodeId} from './abstract-binary-tree';
+import {BinaryTreeNodeKey} from './abstract-binary-tree';
 
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
 
 // 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

package/src/types/data-structures/tree-multiset.ts

@@ -3,4 +3,4 @@ import {AVLTreeOptions} from './avl-tree';
 
 export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeById'> & {}
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {}