data-structure-typed 1.41.6 → 1.41.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.41.6",
+  "version": "1.41.7",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/src/index.js",
   "module": "dist/mjs/src/index.js",
@@ -64,10 +64,10 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.41.2",
+    "avl-tree-typed": "^1.41.6",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.41.2",
-    "bst-typed": "^1.41.2",
+    "binary-tree-typed": "^1.41.6",
+    "bst-typed": "^1.41.6",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
@@ -75,7 +75,7 @@
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
     "fast-glob": "^3.3.1",
-    "heap-typed": "^1.41.2",
+    "heap-typed": "^1.41.6",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -233,8 +233,8 @@ export abstract class AbstractGraph<
       return [];
     }
 
-    const dfs = (cur: VO, dest: VO, visiting: Map<VO, boolean>, path: VO[]) => {
-      visiting.set(cur, true);
+    const dfs = (cur: VO, dest: VO, visiting: Set<VO>, path: VO[]) => {
+      visiting.add(cur);
 
       if (cur === dest) {
         paths.push([vertex1, ...path]);
@@ -242,17 +242,17 @@ export abstract class AbstractGraph<
 
       const neighbors = this.getNeighbors(cur);
       for (const neighbor of neighbors) {
-        if (!visiting.get(neighbor)) {
+        if (!visiting.has(neighbor)) {
           path.push(neighbor);
           dfs(neighbor, dest, visiting, path);
-          arrayRemove(path, (vertex: VO) => vertex === neighbor);
+          path.pop();
         }
       }
 
-      visiting.set(cur, false);
+      visiting.delete(cur);
     };
 
-    dfs(vertex1, vertex2, new Map<VO, boolean>(), []);
+    dfs(vertex1, vertex2, new Set<VO>(), []);
     return paths;
   }
 

package/test/config.ts

@@ -0,0 +1 @@
+export const isDebugTest = false;

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

@@ -0,0 +1,110 @@
+import {AVLTree, CP} from 'avl-tree-typed';
+
+describe('AVL Tree Test', () => {
+  it('should perform various operations on a AVL Tree', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree();
+
+    for (const i of arr) tree.add(i, i);
+
+    const node6 = tree.get(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getValueById = tree.get(10);
+    expect(getValueById).toBe(10);
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+
+    const node15 = tree.getNode(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    // 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?.value).toBe(15);
+
+    const dfs = tree.dfs(node => node, 'in');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(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();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});

package/test/integration/bst.test.ts

@@ -0,0 +1,385 @@
+import {BST, BSTNode, CP} from 'bst-typed';
+
+describe('Individual package BST operations test', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+    const bst = new BST();
+    expect(bst).toBeInstanceOf(BST);
+    bst.add(11, 11);
+    bst.add(3, 3);
+    const idsOrValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    bst.addMany(idsOrValues, idsOrValues, false);
+    expect(bst.root).toBeInstanceOf(BSTNode);
+
+    if (bst.root) expect(bst.root.key).toBe(11);
+
+    expect(bst.size).toBe(16);
+
+    expect(bst.has(6)).toBe(true);
+
+    const node6 = bst.get(6);
+    expect(node6 && bst.getHeight(6)).toBe(2);
+    expect(node6 && bst.getDepth(6)).toBe(3);
+
+    const nodeId10 = bst.getNode(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = bst.getNode(9, node => node.value);
+    expect(nodeVal9?.key).toBe(9);
+
+    const leftMost = bst.getLeftMost();
+    expect(leftMost?.key).toBe(1);
+
+    const node15 = bst.getNode(15);
+    const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15).toBeInstanceOf(BSTNode);
+
+    const node11 = bst.getNode(11);
+    expect(node11).toBeInstanceOf(BSTNode);
+
+    const dfsInorderNodes = bst.dfs(node => node, 'in');
+    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 => node);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
+
+    const removed11 = bst.delete(11);
+    expect(removed11).toBeInstanceOf(Array);
+    expect(removed11[0]).toBeDefined();
+    expect(removed11[0].deleted).toBeDefined();
+
+    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+
+    expect(bst.getHeight(15)).toBe(1);
+
+    const removed1 = bst.delete(1);
+    expect(removed1).toBeInstanceOf(Array);
+    expect(removed1[0]).toBeDefined();
+    expect(removed1[0].deleted).toBeDefined();
+    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+
+    expect(bst.getHeight()).toBe(4);
+
+    const removed4 = bst.delete(4);
+    expect(removed4).toBeInstanceOf(Array);
+    expect(removed4[0]).toBeDefined();
+    expect(removed4[0].deleted).toBeDefined();
+    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(4);
+
+    const removed10 = bst.delete(10);
+    expect(removed10).toBeInstanceOf(Array);
+    expect(removed10[0]).toBeDefined();
+    expect(removed10[0].deleted).toBeDefined();
+    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(4);
+
+    const removed15 = bst.delete(15);
+    expect(removed15).toBeInstanceOf(Array);
+    expect(removed15[0]).toBeDefined();
+    expect(removed15[0].deleted).toBeDefined();
+    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed5 = bst.delete(5);
+    expect(removed5).toBeInstanceOf(Array);
+    expect(removed5[0]).toBeDefined();
+    expect(removed5[0].deleted).toBeDefined();
+    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed13 = bst.delete(13);
+    expect(removed13).toBeInstanceOf(Array);
+    expect(removed13[0]).toBeDefined();
+    expect(removed13[0].deleted).toBeDefined();
+    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed3 = bst.delete(3);
+    expect(removed3).toBeInstanceOf(Array);
+    expect(removed3[0]).toBeDefined();
+    expect(removed3[0].deleted).toBeDefined();
+    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed8 = bst.delete(8);
+    expect(removed8).toBeInstanceOf(Array);
+    expect(removed8[0]).toBeDefined();
+    expect(removed8[0].deleted).toBeDefined();
+    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed6 = bst.delete(6);
+    expect(removed6).toBeInstanceOf(Array);
+    expect(removed6[0]).toBeDefined();
+    expect(removed6[0].deleted).toBeDefined();
+    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
+    expect(bst.delete(6).length).toBe(0);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed7 = bst.delete(7);
+    expect(removed7).toBeInstanceOf(Array);
+    expect(removed7[0]).toBeDefined();
+    expect(removed7[0].deleted).toBeDefined();
+    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed9 = bst.delete(9);
+    expect(removed9).toBeInstanceOf(Array);
+    expect(removed9[0]).toBeDefined();
+    expect(removed9[0].deleted).toBeDefined();
+    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed14 = bst.delete(14);
+    expect(removed14).toBeInstanceOf(Array);
+    expect(removed14[0]).toBeDefined();
+    expect(removed14[0].deleted).toBeDefined();
+    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(2);
+
+    expect(bst.isAVLBalanced()).toBe(false);
+
+    const bfsIDs = bst.bfs();
+    expect(bfsIDs[0]).toBe(2);
+    expect(bfsIDs[1]).toBe(12);
+    expect(bfsIDs[2]).toBe(16);
+
+    const bfsNodes = bst.bfs(node => node);
+    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<{key: number; keyA: number}>();
+    expect(objBST).toBeInstanceOf(BST);
+    objBST.add(11, {key: 11, keyA: 11});
+    objBST.add(3, {key: 3, keyA: 3});
+    const values = [
+      {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.key),
+      values,
+      false
+    );
+
+    expect(objBST.root).toBeInstanceOf(BSTNode);
+
+    if (objBST.root) expect(objBST.root.key).toBe(11);
+
+    expect(objBST.has(6)).toBe(true);
+
+    const node6 = objBST.getNode(6);
+    expect(node6 && objBST.getHeight(node6)).toBe(2);
+    expect(node6 && objBST.getDepth(node6)).toBe(3);
+
+    const nodeId10 = objBST.get(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = objBST.get(9);
+    expect(nodeVal9?.key).toBe(9);
+
+    const leftMost = objBST.getLeftMost();
+    expect(leftMost?.key).toBe(1);
+
+    const node15 = objBST.getNode(15);
+    expect(node15?.value).toEqual({key: 15, keyA: 15});
+    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15).toBeInstanceOf(BSTNode);
+
+    const node11 = objBST.getNode(11);
+    expect(node11).toBeInstanceOf(BSTNode);
+
+    const dfsInorderNodes = objBST.dfs(node => node, 'in');
+    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 => node);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
+
+    const removed11 = objBST.delete(11);
+    expect(removed11).toBeInstanceOf(Array);
+    expect(removed11[0]).toBeDefined();
+    expect(removed11[0].deleted).toBeDefined();
+
+    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+
+    expect(node15 && objBST.getHeight(node15)).toBe(2);
+
+    const removed1 = objBST.delete(1);
+    expect(removed1).toBeInstanceOf(Array);
+    expect(removed1[0]).toBeDefined();
+    expect(removed1[0].deleted).toBeDefined();
+    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed4 = objBST.delete(4);
+    expect(removed4).toBeInstanceOf(Array);
+    expect(removed4[0]).toBeDefined();
+    expect(removed4[0].deleted).toBeDefined();
+    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed10 = objBST.delete(10);
+    expect(removed10).toBeInstanceOf(Array);
+    expect(removed10[0]).toBeDefined();
+    expect(removed10[0].deleted).toBeDefined();
+    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed15 = objBST.delete(15);
+    expect(removed15).toBeInstanceOf(Array);
+    expect(removed15[0]).toBeDefined();
+    expect(removed15[0].deleted).toBeDefined();
+    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed5 = objBST.delete(5);
+    expect(removed5).toBeInstanceOf(Array);
+    expect(removed5[0]).toBeDefined();
+    expect(removed5[0].deleted).toBeDefined();
+    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed13 = objBST.delete(13);
+    expect(removed13).toBeInstanceOf(Array);
+    expect(removed13[0]).toBeDefined();
+    expect(removed13[0].deleted).toBeDefined();
+    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed3 = objBST.delete(3);
+    expect(removed3).toBeInstanceOf(Array);
+    expect(removed3[0]).toBeDefined();
+    expect(removed3[0].deleted).toBeDefined();
+    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed8 = objBST.delete(8);
+    expect(removed8).toBeInstanceOf(Array);
+    expect(removed8[0]).toBeDefined();
+    expect(removed8[0].deleted).toBeDefined();
+    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed6 = objBST.delete(6);
+    expect(removed6).toBeInstanceOf(Array);
+    expect(removed6[0]).toBeDefined();
+    expect(removed6[0].deleted).toBeDefined();
+    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
+    expect(objBST.delete(6).length).toBe(0);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed7 = objBST.delete(7);
+    expect(removed7).toBeInstanceOf(Array);
+    expect(removed7[0]).toBeDefined();
+    expect(removed7[0].deleted).toBeDefined();
+    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed9 = objBST.delete(9);
+    expect(removed9).toBeInstanceOf(Array);
+    expect(removed9[0]).toBeDefined();
+    expect(removed9[0].deleted).toBeDefined();
+    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed14 = objBST.delete(14);
+    expect(removed14).toBeInstanceOf(Array);
+    expect(removed14[0]).toBeDefined();
+    expect(removed14[0].deleted).toBeDefined();
+    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(2);
+
+    expect(objBST.isAVLBalanced()).toBe(false);
+
+    const bfsIDs = objBST.bfs();
+    expect(bfsIDs[0]).toBe(2);
+    expect(bfsIDs[1]).toBe(12);
+    expect(bfsIDs[2]).toBe(16);
+
+    const bfsNodes = objBST.bfs(node => node);
+    expect(bfsNodes[0].key).toBe(2);
+    expect(bfsNodes[1].key).toBe(12);
+    expect(bfsNodes[2].key).toBe(16);
+  });
+});

package/test/integration/heap.test.js

@@ -0,0 +1,16 @@
+const {MinHeap} = require('heap-typed');
+
+describe('JS Heap Operation Test', () => {
+  it('should numeric heap work well', function () {
+    const minNumHeap = new MinHeap();
+    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    expect(minNumHeap.poll()).toBe(0);
+    expect(minNumHeap.poll()).toBe(1);
+    expect(minNumHeap.peek()).toBe(2);
+    expect(minNumHeap.toArray().length).toBe(4);
+    expect(minNumHeap.toArray()[0]).toBe(2);
+    expect(minNumHeap.toArray()[1]).toBe(5);
+    expect(minNumHeap.toArray()[2]).toBe(9);
+    expect(minNumHeap.toArray()[3]).toBe(6);
+  });
+});

package/test/integration/index.html

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang='en'>
+<head>
+  <meta charset='UTF-8'>
+  <title>CDN Test</title>
+  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>
+</head>
+<body>
+<div id='app'>
+  <ul class='modules'>
+
+  </ul>
+</div>
+<script defer>
+  const $modules = document.querySelector('.modules');
+
+
+  try {
+    const {AVLTree, Queue} = window.dataStructureTyped;
+    const avlTree = new AVLTree();
+    const $avlTree = document.createElement('li');
+    const $avlTreeSpan = document.createElement('span');
+    $avlTreeSpan.innerText = 'AVLTree';
+    $avlTree.append($avlTreeSpan);
+    avlTree.add(1, 1);
+    console.log(avlTree.bfs());
+    $modules.append($avlTree);
+
+
+    const queue = new Queue();
+    for (let i = 0; i < 1000000; i++) {
+      queue.enqueue(i);
+    }
+    let last = 0;
+    const startTime = performance.now();
+
+    for (let i = 0; i < 1000000; i++) {
+      last = queue.dequeue();
+    }
+
+    console.log(performance.now() - startTime);
+
+  } catch (e) {
+    console.error(e);
+  }
+
+</script>
+
+</body>
+</html>
+

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

@@ -0,0 +1,36 @@
+import {AVLTree} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomIntArray, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const avl = new AVLTree<number>();
+const {N_LOG_N} = magnitude;
+const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
+
+suite
+  .add(`${N_LOG_N} add randomly`, () => {
+    avl.clear();
+    for (let i = 0; i < arr.length; i++) {
+      avl.add(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} add & delete randomly`, () => {
+    avl.clear();
+    for (let i = 0; i < arr.length; i++) {
+      avl.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      avl.delete(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} addMany`, () => {
+    avl.clear();
+    avl.addMany(arr);
+  })
+  .add(`${N_LOG_N} get`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      avl.get(arr[i]);
+    }
+  });
+
+export {suite};