data-structure-typed 1.34.7 → 1.34.9

package/test/unit/data-structures/binary-tree/tree-multiset.test.ts

@@ -11,21 +11,21 @@ describe('TreeMultiset operations test', () => {
     treeMultiset.addMany(idAndValues, idAndValues);
     expect(treeMultiset.root instanceof TreeMultisetNode);
 
-    if (treeMultiset.root) expect(treeMultiset.root.id == 11);
+    if (treeMultiset.root) expect(treeMultiset.root.key == 11);
 
     expect(treeMultiset.size).toBe(16);
     expect(treeMultiset.count).toBe(18);
-    expect(treeMultiset.BFS('id'));
+    expect(treeMultiset.bfs('key'));
 
     expect(treeMultiset.has(6));
 
     expect(treeMultiset.getHeight(6)).toBe(3);
     expect(treeMultiset.getDepth(6)).toBe(1);
     const nodeId10 = treeMultiset.get(10);
-    expect(nodeId10?.id).toBe(10);
+    expect(nodeId10?.key).toBe(10);
 
     const nodeVal9 = treeMultiset.get(9, 'val');
-    expect(nodeVal9?.id).toBe(9);
+    expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = treeMultiset.getNodesByCount(1);
     expect(nodesByCount1.length).toBe(14);
@@ -33,11 +33,11 @@ describe('TreeMultiset operations test', () => {
     const nodesByCount2 = treeMultiset.getNodesByCount(2);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = treeMultiset.getLeftMost();
-    expect(leftMost?.id).toBe(1);
+    expect(leftMost?.key).toBe(1);
 
     const node15 = treeMultiset.get(15);
     const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.id).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(12);
 
     const subTreeSum = node15 && treeMultiset.subTreeSum(15);
     expect(subTreeSum).toBe(70);
@@ -56,9 +56,9 @@ describe('TreeMultiset operations test', () => {
       expect(allGreaterNodesAdded);
     }
 
-    const dfsInorderNodes = treeMultiset.DFS('in', 'node');
-    expect(dfsInorderNodes[0].id).toBe(1);
-    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+    const dfsInorderNodes = treeMultiset.dfs('in', 'node');
+    expect(dfsInorderNodes[0].key).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(treeMultiset.isPerfectlyBalanced()).toBe(false);
 
     treeMultiset.perfectlyBalance();
@@ -66,16 +66,16 @@ describe('TreeMultiset operations test', () => {
     expect(treeMultiset.isPerfectlyBalanced()).toBe(true);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced = treeMultiset.BFS('node');
-    expect(bfsNodesAfterBalanced[0].id).toBe(8);
-    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
+    const bfsNodesAfterBalanced = treeMultiset.bfs('node');
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
     const removed11 = treeMultiset.remove(11, true);
     expect(removed11 instanceof Array);
     expect(removed11[0]);
     expect(removed11[0].deleted);
 
-    if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
@@ -85,7 +85,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed1 instanceof Array);
     expect(removed1[0]);
     expect(removed1[0].deleted);
-    if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
@@ -95,7 +95,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed4 instanceof Array);
     expect(removed4[0]);
     expect(removed4[0].deleted);
-    if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(4);
@@ -104,7 +104,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed10 instanceof Array);
     expect(removed10[0]);
     expect(removed10[0].deleted);
-    if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
     expect(treeMultiset.getHeight()).toBe(3);
@@ -113,7 +113,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed15 instanceof Array);
     expect(removed15[0]);
     expect(removed15[0].deleted);
-    if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(3);
@@ -122,7 +122,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed5 instanceof Array);
     expect(removed5[0]);
     expect(removed5[0].deleted);
-    if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(3);
@@ -131,7 +131,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed13 instanceof Array);
     expect(removed13[0]);
     expect(removed13[0].deleted);
-    if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(3);
 
@@ -139,7 +139,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed3 instanceof Array);
     expect(removed3[0]);
     expect(removed3[0].deleted);
-    if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(3);
 
@@ -147,7 +147,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed8 instanceof Array);
     expect(removed8[0]);
     expect(removed8[0].deleted);
-    if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(3);
 
@@ -155,7 +155,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed6 instanceof Array);
     expect(removed6[0]);
     expect(removed6[0].deleted);
-    if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
     expect(treeMultiset.remove(6, true).length).toBe(0);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
@@ -165,7 +165,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed7 instanceof Array);
     expect(removed7[0]);
     expect(removed7[0].deleted);
-    if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(2);
 
@@ -173,7 +173,7 @@ describe('TreeMultiset operations test', () => {
     expect(removed9 instanceof Array);
     expect(removed9[0]);
     expect(removed9[0].deleted);
-    if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(2);
 
@@ -181,57 +181,57 @@ describe('TreeMultiset operations test', () => {
     expect(removed14 instanceof Array);
     expect(removed14[0]);
     expect(removed14[0].deleted);
-    if (removed14[0].deleted) expect(removed14[0].deleted.id).toBe(14);
+    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
     expect(treeMultiset.getHeight()).toBe(1);
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
-    const bfsIDs = treeMultiset.BFS();
+    const bfsIDs = treeMultiset.bfs();
 
     expect(bfsIDs[0]).toBe(12);
     expect(bfsIDs[1]).toBe(2);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes = treeMultiset.BFS('node');
+    const bfsNodes = treeMultiset.bfs('node');
 
-    expect(bfsNodes[0].id).toBe(12);
-    expect(bfsNodes[1].id).toBe(2);
-    expect(bfsNodes[2].id).toBe(16);
+    expect(bfsNodes[0].key).toBe(12);
+    expect(bfsNodes[1].key).toBe(2);
+    expect(bfsNodes[2].key).toBe(16);
 
     expect(treeMultiset.count).toBe(9);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<TreeMultisetNode<{id: number; keyA: number}>>();
+    const objTreeMultiset = new TreeMultiset<TreeMultisetNode<{key: number; keyA: number}>>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
-    objTreeMultiset.add(11, {id: 11, keyA: 11});
-    objTreeMultiset.add(3, {id: 3, keyA: 3});
+    objTreeMultiset.add(11, {key: 11, keyA: 11});
+    objTreeMultiset.add(3, {key: 3, keyA: 3});
     const values = [
-      {id: 15, keyA: 15},
-      {id: 1, keyA: 1},
-      {id: 8, keyA: 8},
-      {id: 13, keyA: 13},
-      {id: 16, keyA: 16},
-      {id: 2, keyA: 2},
-      {id: 6, keyA: 6},
-      {id: 9, keyA: 9},
-      {id: 12, keyA: 12},
-      {id: 14, keyA: 14},
-      {id: 4, keyA: 4},
-      {id: 7, keyA: 7},
-      {id: 10, keyA: 10},
-      {id: 5, keyA: 5}
+      {key: 15, keyA: 15},
+      {key: 1, keyA: 1},
+      {key: 8, keyA: 8},
+      {key: 13, keyA: 13},
+      {key: 16, keyA: 16},
+      {key: 2, keyA: 2},
+      {key: 6, keyA: 6},
+      {key: 9, keyA: 9},
+      {key: 12, keyA: 12},
+      {key: 14, keyA: 14},
+      {key: 4, keyA: 4},
+      {key: 7, keyA: 7},
+      {key: 10, keyA: 10},
+      {key: 5, keyA: 5}
     ];
 
     objTreeMultiset.addMany(
-      values.map(item => item.id),
+      values.map(item => item.key),
       values
     );
 
     expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode);
 
-    if (objTreeMultiset.root) expect(objTreeMultiset.root.id).toBe(11);
+    if (objTreeMultiset.root) expect(objTreeMultiset.root.key).toBe(11);
 
     expect(objTreeMultiset.count).toBe(16);
 
@@ -241,22 +241,22 @@ describe('TreeMultiset operations test', () => {
     // expect(node6 && objTreeMultiset.getHeight(node6)).toBe(2);
     // expect(node6 && objTreeMultiset.getDepth(node6)).toBe(3);
     //
-    // const nodeId10 = objTreeMultiset.get(10, 'id');
-    // expect(nodeId10?.id).toBe(10);
+    // const nodeId10 = objTreeMultiset.get(10, 'key');
+    // expect(nodeId10?.key).toBe(10);
     //
-    // const nodeVal9 = objTreeMultiset.get(9, 'id');
-    // expect(nodeVal9?.id).toBe(9);
+    // const nodeVal9 = objTreeMultiset.get(9, 'key');
+    // expect(nodeVal9?.key).toBe(9);
     //
     // const nodesByCount1 = objTreeMultiset.getNodesByCount(1);
     // expect(nodesByCount1.length).toBe(16);
     //
     // const leftMost = objTreeMultiset.getLeftMost();
-    // expect(leftMost?.id).toBe(1);
+    // expect(leftMost?.key).toBe(1);
     //
     // const node15 = objTreeMultiset.get(15);
-    // expect(node15?.val).toEqual({id: 15, keyA: 15});
+    // expect(node15?.val).toEqual({key: 15, keyA: 15});
     // const minNodeBySpecificNode = node15 && objTreeMultiset.getLeftMost(node15);
-    // expect(minNodeBySpecificNode?.id).toBe(12);
+    // expect(minNodeBySpecificNode?.key).toBe(12);
     //
     // const subTreeSum = node15 && objTreeMultiset.subTreeSum(node15);
     // expect(subTreeSum).toBe(70);
@@ -277,23 +277,23 @@ describe('TreeMultiset operations test', () => {
     //     expect(allGreaterNodesAdded).toBeDefined();
     // }
     //
-    // const dfsInorderNodes = objTreeMultiset.DFS('in', 'node');
-    // expect(dfsInorderNodes[0].id).toBe(1);
-    // expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+    // const dfsInorderNodes = objTreeMultiset.dfs('in', 'node');
+    // expect(dfsInorderNodes[0].key).toBe(1);
+    // expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     //
     // objTreeMultiset.perfectlyBalance();
     // expect(objTreeMultiset.isPerfectlyBalanced()).toBe(true);
     //
-    // const bfsNodesAfterBalanced = objTreeMultiset.BFS('node');
-    // expect(bfsNodesAfterBalanced[0].id).toBe(8);
-    // expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
+    // const bfsNodesAfterBalanced = objTreeMultiset.bfs('node');
+    // expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    // expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
     //
     // const removed11 = objTreeMultiset.remove(11, true);
     // expect(removed11).toBeInstanceOf(Array);
     // expect(removed11[0]).toBeDefined();
     // expect(removed11[0].deleted).toBeDefined();
     //
-    // if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+    // if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
     //
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     //
@@ -303,7 +303,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed1).toBeInstanceOf(Array);
     // expect(removed1[0]).toBeDefined();
     // expect(removed1[0].deleted).toBeDefined();
-    // if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+    // if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
     //
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     //
@@ -313,7 +313,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed4).toBeInstanceOf(Array);
     // expect(removed4[0]).toBeDefined();
     // expect(removed4[0].deleted).toBeDefined();
-    // if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+    // if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     // expect(objTreeMultiset.getHeight()).toBe(4);
     //
@@ -321,7 +321,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed10).toBeInstanceOf(Array);
     // expect(removed10[0]).toBeDefined();
     // expect(removed10[0].deleted).toBeDefined();
-    // if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+    // if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     // expect(objTreeMultiset.getHeight()).toBe(4);
     //
@@ -329,7 +329,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed15).toBeInstanceOf(Array);
     // expect(removed15[0]).toBeDefined();
     // expect(removed15[0].deleted).toBeDefined();
-    // if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+    // if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
     //
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     // expect(objTreeMultiset.getHeight()).toBe(3);
@@ -338,7 +338,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed5).toBeInstanceOf(Array);
     // expect(removed5[0]).toBeDefined();
     // expect(removed5[0].deleted).toBeDefined();
-    // if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+    // if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
     //
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     // expect(objTreeMultiset.getHeight()).toBe(3);
@@ -347,7 +347,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed13).toBeInstanceOf(Array);
     // expect(removed13[0]).toBeDefined();
     // expect(removed13[0].deleted).toBeDefined();
-    // if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+    // if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     // expect(objTreeMultiset.getHeight()).toBe(3);
     //
@@ -355,7 +355,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed3).toBeInstanceOf(Array);
     // expect(removed3[0]).toBeDefined();
     // expect(removed3[0].deleted).toBeDefined();
-    // if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+    // if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     // expect(objTreeMultiset.getHeight()).toBe(3);
     //
@@ -363,7 +363,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed8).toBeInstanceOf(Array);
     // expect(removed8[0]).toBeDefined();
     // expect(removed8[0].deleted).toBeDefined();
-    // if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+    // if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
     // expect(objTreeMultiset.getHeight()).toBe(3);
     //
@@ -371,7 +371,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed6).toBeInstanceOf(Array);
     // expect(removed6[0]).toBeDefined();
     // expect(removed6[0].deleted).toBeDefined();
-    // if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+    // if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
     // expect(objTreeMultiset.remove(6, true).length).toBe(0);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     // expect(objTreeMultiset.getHeight()).toBe(3);
@@ -380,7 +380,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed7).toBeInstanceOf(Array);
     // expect(removed7[0]).toBeDefined();
     // expect(removed7[0].deleted).toBeDefined();
-    // if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+    // if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     // expect(objTreeMultiset.getHeight()).toBe(3);
     //
@@ -388,7 +388,7 @@ describe('TreeMultiset operations test', () => {
     // expect(removed9).toBeInstanceOf(Array);
     // expect(removed9[0]).toBeDefined();
     // expect(removed9[0].deleted).toBeDefined();
-    // if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+    // if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     // expect(objTreeMultiset.getHeight()).toBe(3);
     //
@@ -396,22 +396,22 @@ describe('TreeMultiset operations test', () => {
     // expect(removed14).toBeInstanceOf(Array);
     // expect(removed14[0]).toBeDefined();
     // expect(removed14[0].deleted).toBeDefined();
-    // if (removed14[0].deleted) expect(removed14[0].deleted.id).toBe(14);
+    // if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     // expect(objTreeMultiset.getHeight()).toBe(2);
     //
     //
     // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
     //
-    // const bfsIDs = objTreeMultiset.BFS();
+    // const bfsIDs = objTreeMultiset.bfs();
     // expect(bfsIDs[0]).toBe(2);
     // expect(bfsIDs[1]).toBe(12);
     // expect(bfsIDs[2]).toBe(16);
     //
-    // const bfsNodes = objTreeMultiset.BFS('node');
-    // expect(bfsNodes[0].id).toBe(2);
-    // expect(bfsNodes[1].id).toBe(12);
-    // expect(bfsNodes[2].id).toBe(16);
+    // const bfsNodes = objTreeMultiset.bfs('node');
+    // expect(bfsNodes[0].key).toBe(2);
+    // expect(bfsNodes[1].key).toBe(12);
+    // expect(bfsNodes[2].key).toBe(16);
     //
     // expect(objTreeMultiset.count).toBe(5);
   });

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -63,8 +63,8 @@ describe('DirectedGraph Operation Test', () => {
 });
 
 class MyVertex<V extends string> extends DirectedVertex<V> {
-  constructor(id: VertexId, val?: V) {
-    super(id, val);
+  constructor(key: VertexId, val?: V) {
+    super(key, val);
     this._data = val;
   }
 
@@ -97,8 +97,8 @@ class MyEdge<E extends string> extends DirectedEdge<E> {
 }
 
 class MyDirectedGraph<V extends MyVertex<string>, E extends MyEdge<string>> extends DirectedGraph<V, E> {
-  createVertex(id: VertexId, val: V['val']): V {
-    return new MyVertex(id, val) as V;
+  createVertex(key: VertexId, val: V['val']): V {
+    return new MyVertex(key, val) as V;
   }
 
   createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E {
@@ -183,7 +183,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
       expect(sorted.length).toBe(9);
       if (sorted[0] instanceof MyVertex) expect(sorted[0].data).toBe('data9');
       sorted[3] instanceof MyVertex && expect(sorted[3].data).toBe('data6');
-      sorted[8] instanceof MyVertex && expect(sorted[8].id).toBe(1);
+      sorted[8] instanceof MyVertex && expect(sorted[8].key).toBe(1);
     }
   });
 
@@ -266,9 +266,9 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     if (minPath1to7 && minPath1to7.length > 0) {
       expect(minPath1to7).toHaveLength(3);
       expect(minPath1to7[0]).toBeInstanceOf(MyVertex);
-      expect(minPath1to7[0].id).toBe(1);
-      expect(minPath1to7[1].id).toBe(9);
-      expect(minPath1to7[2].id).toBe(7);
+      expect(minPath1to7[0].key).toBe(1);
+      expect(minPath1to7[1].key).toBe(9);
+      expect(minPath1to7[2].key).toBe(7);
     }
 
     const fordResult1 = myGraph.bellmanFord(1);

package/test/unit/data-structures/graph/map-graph.test.ts

@@ -30,16 +30,16 @@ describe('MapGraph Operation Test', () => {
     const expected1 = ['Surin', 'Lotus', 'The Breeza', 'Trinity Auto', 'Saanen Goat Farm'];
 
     const minPathBetween = mapGraph.getMinPathBetween('Surin', 'Saanen Goat Farm');
-    expect(minPathBetween?.map(v => v.id)).toEqual(expected1);
+    expect(minPathBetween?.map(v => v.key)).toEqual(expected1);
     const surinToSaanenGoatFarmDij = mapGraph.dijkstra('Surin', 'Saanen Goat Farm', true, true);
-    expect(surinToSaanenGoatFarmDij?.minPath.map(v => v.id)).toEqual(expected1);
+    expect(surinToSaanenGoatFarmDij?.minPath.map(v => v.key)).toEqual(expected1);
     expect(surinToSaanenGoatFarmDij?.minDist).toBe(41.1);
     mapGraph.addEdge('Surin', 'Batu Feringgi Beach', 1.5);
     const expected2 = ['Surin', 'Batu Feringgi Beach', 'Hard Rock Hotel', 'Saanen Goat Farm'];
     const minPathBetweenViaBFB = mapGraph.getMinPathBetween('Surin', 'Saanen Goat Farm', true);
-    expect(minPathBetweenViaBFB?.map(v => v.id)).toEqual(expected2);
+    expect(minPathBetweenViaBFB?.map(v => v.key)).toEqual(expected2);
     const surinToSaanenGoatFarmViaDij = mapGraph.dijkstra('Surin', 'Saanen Goat Farm', true, true);
-    expect(surinToSaanenGoatFarmViaDij?.minPath.map(v => v.id)).toEqual(expected2);
+    expect(surinToSaanenGoatFarmViaDij?.minPath.map(v => v.key)).toEqual(expected2);
     expect(surinToSaanenGoatFarmViaDij?.minDist).toBe(25.2);
   });
 });

package/test/unit/data-structures/graph/overall.test.ts

@@ -43,7 +43,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addEdge('B', 'D');
 
     const dijkstraResult = graph.dijkstra('A');
-    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id); // ['A', 'B', 'D']
-    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id)).toEqual(['A', 'B', 'D']);
+    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key); // ['A', 'B', 'D']
+    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
   });
 });

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -54,6 +54,6 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addEdge('B', 'D');
 
     const dijkstraResult = graph.dijkstra('A');
-    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id)).toEqual(['A', 'B', 'D']);
+    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
   });
 });

package/test/unit/data-structures/priority-queue/priority-queue.test.ts

@@ -48,14 +48,14 @@ describe('PriorityQueue Operation Test', () => {
     ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
   });
 
-  it('should PriorityQueue clone, sort, getNodes, DFS work well', function () {
+  it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
     const minPQ1 = new PriorityQueue<number>({nodes: [2, 5, 8, 3, 1, 6, 7, 4], comparator: (a, b) => a - b});
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
     expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-    expect(minPQ1.DFS('in')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
-    expect(minPQ1.DFS('post')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
-    expect(minPQ1.DFS('pre')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
+    expect(minPQ1.dfs('in')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
+    expect(minPQ1.dfs('post')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
+    expect(minPQ1.dfs('pre')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
   });
 });
 
@@ -67,4 +67,3 @@ describe('Priority Queue Performance Test', () => {
     expect(sorted).toEqual(values.sort((a, b) => a - b));
   });
 });
-

package/test/unit/data-structures/tree/tree.test.ts

@@ -1,9 +1,9 @@
 import {TreeNode} from '../../../../src';
 
 describe('TreeNode', () => {
-  it('should create a TreeNode with the given id and value', () => {
+  it('should create a TreeNode with the given key and value', () => {
     const node = new TreeNode<string>('1', 'Node 1');
-    expect(node.id).toBe('1');
+    expect(node.key).toBe('1');
     expect(node.value).toBe('Node 1');
     expect(node.children).toEqual([]);
   });