data-structure-typed 1.34.7 → 1.34.9

package/src/types/utils/validate-type.ts

@@ -1,26 +1,26 @@
 export type KeyValueObject = {[key: string]: any};
 
-export type KeyValueObjectWithId = {[key: string]: any; id: string | number | symbol};
+export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 
-export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
+export type ObjectWithoutKey = Omit<KeyValueObject, 'key'>;
 
-export type ObjectWithNonNumberId = {
+export type ObjectWithNonNumberKey = {
   [key: string]: any;
-  id: string | boolean | symbol | null | object | undefined;
+  key: string | boolean | symbol | null | object | undefined;
 };
 
-export type ObjectWithNumberId = {
+export type ObjectWithNumberKey = {
   [key: string]: any;
-  id: number;
+  key: number;
 };
 
-export type RestrictValById =
+export type RestrictValByKey =
   | NonNumberNonObjectButDefined
-  | ObjectWithoutId
-  | ObjectWithNonNumberId
-  | ObjectWithNumberId;
+  | ObjectWithoutKey
+  | ObjectWithNonNumberKey
+  | ObjectWithNumberKey;
 
 export type DummyAny =
   | string

package/test/integration/avl-tree.test.ts

@@ -12,15 +12,15 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10, 'id');
-    expect(getNodeById?.id).toBe(10);
+    const getNodeById = tree.get(10, 'key');
+    expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
-    expect(getMinNodeByRoot?.id).toBe(1);
+    expect(getMinNodeByRoot?.key).toBe(1);
 
     const node15 = tree.get(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-    expect(getMinNodeBySpecificNode?.id).toBe(12);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     const subTreeSum = node15 && tree.subTreeSum(node15);
     expect(subTreeSum).toBe(70);
@@ -32,65 +32,65 @@ describe('AVL Tree Test', () => {
     expect(node15?.val).toBe(15);
 
     const dfs = tree.DFS('in', 'node');
-    expect(dfs[0].id).toBe(1);
-    expect(dfs[dfs.length - 1].id).toBe(16);
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
 
     tree.perfectlyBalance();
     const bfs = tree.BFS('node');
     expect(tree.isPerfectlyBalanced()).toBe(true);
-    expect(bfs[0].id).toBe(8);
-    expect(bfs[bfs.length - 1].id).toBe(16);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
 
-    expect(tree.remove(11)[0].deleted?.id).toBe(11);
+    expect(tree.remove(11)[0].deleted?.key).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(node15 && tree.getHeight(node15)).toBe(2);
 
-    expect(tree.remove(1)[0].deleted?.id).toBe(1);
+    expect(tree.remove(1)[0].deleted?.key).toBe(1);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(4)[0].deleted?.id).toBe(4);
+    expect(tree.remove(4)[0].deleted?.key).toBe(4);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(10)[0].deleted?.id).toBe(10);
+    expect(tree.remove(10)[0].deleted?.key).toBe(10);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(15)[0].deleted?.id).toBe(15);
+    expect(tree.remove(15)[0].deleted?.key).toBe(15);
     expect(tree.isAVLBalanced()).toBe(true);
 
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(5)[0].deleted?.id).toBe(5);
+    expect(tree.remove(5)[0].deleted?.key).toBe(5);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(13)[0].deleted?.id).toBe(13);
+    expect(tree.remove(13)[0].deleted?.key).toBe(13);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(3)[0].deleted?.id).toBe(3);
+    expect(tree.remove(3)[0].deleted?.key).toBe(3);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(8)[0].deleted?.id).toBe(8);
+    expect(tree.remove(8)[0].deleted?.key).toBe(8);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(6)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6)[0].deleted?.key).toBe(6);
     expect(tree.remove(6).length).toBe(0);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(7)[0].deleted?.id).toBe(7);
+    expect(tree.remove(7)[0].deleted?.key).toBe(7);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(9)[0].deleted?.id).toBe(9);
+    expect(tree.remove(9)[0].deleted?.key).toBe(9);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
-    expect(tree.remove(14)[0].deleted?.id).toBe(14);
+    expect(tree.remove(14)[0].deleted?.key).toBe(14);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(1);
 
@@ -101,8 +101,8 @@ describe('AVL Tree Test', () => {
     expect(lastBFSIds[2]).toBe(16);
 
     const lastBFSNodes = tree.BFS('node');
-    expect(lastBFSNodes[0].id).toBe(12);
-    expect(lastBFSNodes[1].id).toBe(2);
-    expect(lastBFSNodes[2].id).toBe(16);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
   });
 });

package/test/integration/bst.test.ts

@@ -10,7 +10,7 @@ describe('Individual package BST operations test', () => {
     bst.addMany(idsOrVals, idsOrVals);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
-    if (bst.root) expect(bst.root.id).toBe(11);
+    if (bst.root) expect(bst.root.key).toBe(11);
 
     expect(bst.size).toBe(16);
 
@@ -21,17 +21,17 @@ describe('Individual package BST operations test', () => {
     expect(node6 && bst.getDepth(6)).toBe(3);
 
     const nodeId10 = bst.get(10);
-    expect(nodeId10?.id).toBe(10);
+    expect(nodeId10?.key).toBe(10);
 
     const nodeVal9 = bst.get(9, 'val');
-    expect(nodeVal9?.id).toBe(9);
+    expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
-    expect(leftMost?.id).toBe(1);
+    expect(leftMost?.key).toBe(1);
 
     const node15 = bst.get(15);
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.id).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(12);
 
     const subTreeSum = node15 && bst.subTreeSum(15);
     expect(subTreeSum).toBe(70);
@@ -45,22 +45,22 @@ describe('Individual package BST operations test', () => {
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = bst.DFS('in', 'node');
-    expect(dfsInorderNodes[0].id).toBe(1);
-    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+    expect(dfsInorderNodes[0].key).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
     bst.perfectlyBalance();
     expect(bst.isPerfectlyBalanced()).toBe(true);
 
     const bfsNodesAfterBalanced = bst.BFS('node');
-    expect(bfsNodesAfterBalanced[0].id).toBe(8);
-    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
     const removed11 = bst.remove(11);
     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(bst.isAVLBalanced()).toBe(true);
 
@@ -70,7 +70,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(true);
 
@@ -80,7 +80,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(4);
 
@@ -88,7 +88,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(4);
 
@@ -96,7 +96,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
@@ -105,7 +105,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
@@ -114,7 +114,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
@@ -122,7 +122,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
@@ -130,7 +130,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
@@ -138,7 +138,7 @@ describe('Individual package BST 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(bst.remove(6).length).toBe(0);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
@@ -147,7 +147,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
@@ -155,7 +155,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
@@ -163,7 +163,7 @@ describe('Individual package BST 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(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(2);
 
@@ -175,41 +175,41 @@ describe('Individual package BST operations test', () => {
     expect(bfsIDs[2]).toBe(16);
 
     const bfsNodes = bst.BFS('node');
-    expect(bfsNodes[0].id).toBe(2);
-    expect(bfsNodes[1].id).toBe(12);
-    expect(bfsNodes[2].id).toBe(16);
+    expect(bfsNodes[0].key).toBe(2);
+    expect(bfsNodes[1].key).toBe(12);
+    expect(bfsNodes[2].key).toBe(16);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<BSTNode<{id: number; keyA: number}>>();
+    const objBST = new BST<BSTNode<{key: number; keyA: number}>>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, {id: 11, keyA: 11});
-    objBST.add(3, {id: 3, keyA: 3});
+    objBST.add(11, {key: 11, keyA: 11});
+    objBST.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}
     ];
 
     objBST.addMany(
-      values.map(item => item.id),
+      values.map(item => item.key),
       values
     );
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
-    if (objBST.root) expect(objBST.root.id).toBe(11);
+    if (objBST.root) expect(objBST.root.key).toBe(11);
 
     expect(objBST.has(6)).toBe(true);
 
@@ -217,19 +217,19 @@ describe('Individual package BST operations test', () => {
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
-    const nodeId10 = objBST.get(10, 'id');
-    expect(nodeId10?.id).toBe(10);
+    const nodeId10 = objBST.get(10, 'key');
+    expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = objBST.get(9, 'id');
-    expect(nodeVal9?.id).toBe(9);
+    const nodeVal9 = objBST.get(9, 'key');
+    expect(nodeVal9?.key).toBe(9);
 
     const leftMost = objBST.getLeftMost();
-    expect(leftMost?.id).toBe(1);
+    expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.get(15);
-    expect(node15?.val).toEqual({id: 15, keyA: 15});
+    expect(node15?.val).toEqual({key: 15, keyA: 15});
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.id).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(12);
 
     const subTreeSum = node15 && objBST.subTreeSum(node15);
     expect(subTreeSum).toBe(70);
@@ -243,22 +243,22 @@ describe('Individual package BST operations test', () => {
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = objBST.DFS('in', 'node');
-    expect(dfsInorderNodes[0].id).toBe(1);
-    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+    expect(dfsInorderNodes[0].key).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
     const bfsNodesAfterBalanced = objBST.BFS('node');
-    expect(bfsNodesAfterBalanced[0].id).toBe(8);
-    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
     const removed11 = objBST.remove(11);
     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(objBST.isAVLBalanced()).toBe(true);
 
@@ -268,7 +268,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(true);
 
@@ -278,7 +278,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(4);
 
@@ -286,7 +286,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(4);
 
@@ -294,7 +294,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
@@ -303,7 +303,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
@@ -312,7 +312,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
 
@@ -320,7 +320,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
@@ -328,7 +328,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
 
@@ -336,7 +336,7 @@ describe('Individual package BST 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(objBST.remove(6).length).toBe(0);
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
@@ -345,7 +345,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
@@ -353,7 +353,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
@@ -361,7 +361,7 @@ describe('Individual package BST 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(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(2);
 
@@ -373,8 +373,8 @@ describe('Individual package BST operations test', () => {
     expect(bfsIDs[2]).toBe(16);
 
     const bfsNodes = objBST.BFS('node');
-    expect(bfsNodes[0].id).toBe(2);
-    expect(bfsNodes[1].id).toBe(12);
-    expect(bfsNodes[2].id).toBe(16);
+    expect(bfsNodes[0].key).toBe(2);
+    expect(bfsNodes[1].key).toBe(12);
+    expect(bfsNodes[2].key).toBe(16);
   });
 });

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

@@ -12,15 +12,15 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10, 'id');
-    expect(getNodeById?.id).toBe(10);
+    const getNodeById = tree.get(10, 'key');
+    expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
-    expect(getMinNodeByRoot?.id).toBe(1);
+    expect(getMinNodeByRoot?.key).toBe(1);
 
     const node15 = tree.get(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-    expect(getMinNodeBySpecificNode?.id).toBe(12);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     const subTreeSum = node15 && tree.subTreeSum(node15);
     expect(subTreeSum).toBe(70);
@@ -31,78 +31,78 @@ describe('AVL Tree Test', () => {
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.val).toBe(15);
 
-    const dfs = tree.DFS('in', 'node');
-    expect(dfs[0].id).toBe(1);
-    expect(dfs[dfs.length - 1].id).toBe(16);
+    const dfs = tree.dfs('in', 'node');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
 
     tree.perfectlyBalance();
-    const bfs = tree.BFS('node');
+    const bfs = tree.bfs('node');
     expect(tree.isPerfectlyBalanced()).toBe(true);
-    expect(bfs[0].id).toBe(8);
-    expect(bfs[bfs.length - 1].id).toBe(16);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
 
-    expect(tree.remove(11)[0].deleted?.id).toBe(11);
+    expect(tree.remove(11)[0].deleted?.key).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(node15 && tree.getHeight(node15)).toBe(2);
 
-    expect(tree.remove(1)[0].deleted?.id).toBe(1);
+    expect(tree.remove(1)[0].deleted?.key).toBe(1);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(4)[0].deleted?.id).toBe(4);
+    expect(tree.remove(4)[0].deleted?.key).toBe(4);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(10)[0].deleted?.id).toBe(10);
+    expect(tree.remove(10)[0].deleted?.key).toBe(10);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(15)[0].deleted?.id).toBe(15);
+    expect(tree.remove(15)[0].deleted?.key).toBe(15);
     expect(tree.isAVLBalanced()).toBe(true);
 
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(5)[0].deleted?.id).toBe(5);
+    expect(tree.remove(5)[0].deleted?.key).toBe(5);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(13)[0].deleted?.id).toBe(13);
+    expect(tree.remove(13)[0].deleted?.key).toBe(13);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(3)[0].deleted?.id).toBe(3);
+    expect(tree.remove(3)[0].deleted?.key).toBe(3);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(8)[0].deleted?.id).toBe(8);
+    expect(tree.remove(8)[0].deleted?.key).toBe(8);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(6)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6)[0].deleted?.key).toBe(6);
     expect(tree.remove(6).length).toBe(0);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(7)[0].deleted?.id).toBe(7);
+    expect(tree.remove(7)[0].deleted?.key).toBe(7);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(9)[0].deleted?.id).toBe(9);
+    expect(tree.remove(9)[0].deleted?.key).toBe(9);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
-    expect(tree.remove(14)[0].deleted?.id).toBe(14);
+    expect(tree.remove(14)[0].deleted?.key).toBe(14);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(1);
 
     expect(tree.isAVLBalanced()).toBe(true);
-    const lastBFSIds = tree.BFS();
+    const lastBFSIds = tree.bfs();
     expect(lastBFSIds[0]).toBe(12);
     expect(lastBFSIds[1]).toBe(2);
     expect(lastBFSIds[2]).toBe(16);
 
-    const lastBFSNodes = tree.BFS('node');
-    expect(lastBFSNodes[0].id).toBe(12);
-    expect(lastBFSNodes[1].id).toBe(2);
-    expect(lastBFSNodes[2].id).toBe(16);
+    const lastBFSNodes = tree.bfs('node');
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
   });
 });