data-structure-typed 1.21.3 → 1.31.0

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

@@ -0,0 +1,111 @@
+import {AVLTree} 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 getNodeById = tree.get(10, 'id');
+    expect(getNodeById?.id).toBe(10);
+
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.id).toBe(1);
+
+    const node15 = tree.get(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.id).toBe(12);
+
+    const subTreeSum = node15 && tree.subTreeSum(node15);
+    expect(subTreeSum).toBe(70);
+
+    const lesserSum = tree.lesserSum(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?.val).toBe(15);
+
+    const dfs = tree.DFS('in', 'node');
+    expect(dfs[0].id).toBe(1);
+    expect(dfs[dfs.length - 1].id).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(tree.remove(11, true)[0].deleted?.id).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.remove(1, true)[0].deleted?.id).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.remove(4, true)[0].deleted?.id).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.remove(10, true)[0].deleted?.id).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(15, true)[0].deleted?.id).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(5, true)[0].deleted?.id).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(13, true)[0].deleted?.id).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(3, true)[0].deleted?.id).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(8, true)[0].deleted?.id).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(6, true)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6, true).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.remove(7, true)[0].deleted?.id).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.remove(9, true)[0].deleted?.id).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.remove(14, true)[0].deleted?.id).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');
+    expect(lastBFSNodes[0].id).toBe(12);
+    expect(lastBFSNodes[1].id).toBe(2);
+    expect(lastBFSNodes[2].id).toBe(16);
+  });
+});

package/test/integration/bst.test.ts

@@ -0,0 +1,371 @@
+import {BST, BSTNode} 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 idsOrVals = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    bst.addMany(idsOrVals, idsOrVals);
+    expect(bst.root).toBeInstanceOf(BSTNode);
+
+    if (bst.root) expect(bst.root.id).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.get(10);
+    expect(nodeId10?.id).toBe(10);
+
+    const nodeVal9 = bst.get(9, 'val');
+    expect(nodeVal9?.id).toBe(9);
+
+
+    const leftMost = bst.getLeftMost();
+    expect(leftMost?.id).toBe(1);
+
+    const node15 = bst.get(15);
+    const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.id).toBe(12);
+
+    const subTreeSum = node15 && bst.subTreeSum(15);
+    expect(subTreeSum).toBe(70);
+
+    const lesserSum = bst.lesserSum(10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15).toBeInstanceOf(BSTNode);
+
+    const node11 = bst.get(11);
+    expect(node11).toBeInstanceOf(BSTNode);
+
+    const dfsInorderNodes = bst.DFS('in', 'node');
+    expect(dfsInorderNodes[0].id).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).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);
+
+    const removed11 = bst.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);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+
+    expect(bst.getHeight(15)).toBe(1);
+
+    const removed1 = bst.remove(1, true);
+    expect(removed1).toBeInstanceOf(Array);
+    expect(removed1[0]).toBeDefined();
+    expect(removed1[0].deleted).toBeDefined();
+    if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+
+    expect(bst.getHeight()).toBe(4);
+
+    const removed4 = bst.remove(4, true);
+    expect(removed4).toBeInstanceOf(Array);
+    expect(removed4[0]).toBeDefined();
+    expect(removed4[0].deleted).toBeDefined();
+    if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(4);
+
+    const removed10 = bst.remove(10, true);
+    expect(removed10).toBeInstanceOf(Array);
+    expect(removed10[0]).toBeDefined();
+    expect(removed10[0].deleted).toBeDefined();
+    if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(4);
+
+    const removed15 = bst.remove(15, true);
+    expect(removed15).toBeInstanceOf(Array);
+    expect(removed15[0]).toBeDefined();
+    expect(removed15[0].deleted).toBeDefined();
+    if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed5 = bst.remove(5, true);
+    expect(removed5).toBeInstanceOf(Array);
+    expect(removed5[0]).toBeDefined();
+    expect(removed5[0].deleted).toBeDefined();
+    if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed13 = bst.remove(13, true);
+    expect(removed13).toBeInstanceOf(Array);
+    expect(removed13[0]).toBeDefined();
+    expect(removed13[0].deleted).toBeDefined();
+    if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed3 = bst.remove(3, true);
+    expect(removed3).toBeInstanceOf(Array);
+    expect(removed3[0]).toBeDefined();
+    expect(removed3[0].deleted).toBeDefined();
+    if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed8 = bst.remove(8, true);
+    expect(removed8).toBeInstanceOf(Array);
+    expect(removed8[0]).toBeDefined();
+    expect(removed8[0].deleted).toBeDefined();
+    if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed6 = bst.remove(6, true);
+    expect(removed6).toBeInstanceOf(Array);
+    expect(removed6[0]).toBeDefined();
+    expect(removed6[0].deleted).toBeDefined();
+    if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+    expect(bst.remove(6, true).length).toBe(0);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed7 = bst.remove(7, true);
+    expect(removed7).toBeInstanceOf(Array);
+    expect(removed7[0]).toBeDefined();
+    expect(removed7[0].deleted).toBeDefined();
+    if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed9 = bst.remove(9, true);
+    expect(removed9).toBeInstanceOf(Array);
+    expect(removed9[0]).toBeDefined();
+    expect(removed9[0].deleted).toBeDefined();
+    if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed14 = bst.remove(14, true);
+    expect(removed14).toBeInstanceOf(Array);
+    expect(removed14[0]).toBeDefined();
+    expect(removed14[0].deleted).toBeDefined();
+    if (removed14[0].deleted) expect(removed14[0].deleted.id).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');
+    expect(bfsNodes[0].id).toBe(2);
+    expect(bfsNodes[1].id).toBe(12);
+    expect(bfsNodes[2].id).toBe(16);
+
+  });
+
+  it('should perform various operations on a Binary Search Tree with object values', () => {
+    const objBST = new BST<BSTNode<{ id: number, keyA: number }>>();
+    expect(objBST).toBeInstanceOf(BST);
+    objBST.add(11, {id: 11, keyA: 11});
+    objBST.add(3, {id: 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}];
+
+    objBST.addMany(values.map(item => item.id), values);
+
+    expect(objBST.root).toBeInstanceOf(BSTNode);
+
+    if (objBST.root) expect(objBST.root.id).toBe(11);
+
+    expect(objBST.has(6)).toBe(true);
+
+    const node6 = objBST.get(6);
+    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 nodeVal9 = objBST.get(9, 'id');
+    expect(nodeVal9?.id).toBe(9);
+
+    const leftMost = objBST.getLeftMost();
+    expect(leftMost?.id).toBe(1);
+
+    const node15 = objBST.get(15);
+    expect(node15?.val).toEqual({id: 15, keyA: 15});
+    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.id).toBe(12);
+
+    const subTreeSum = node15 && objBST.subTreeSum(node15);
+    expect(subTreeSum).toBe(70);
+
+    const lesserSum = objBST.lesserSum(10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15).toBeInstanceOf(BSTNode);
+
+    const node11 = objBST.get(11);
+    expect(node11).toBeInstanceOf(BSTNode);
+
+    const dfsInorderNodes = objBST.DFS('in', 'node');
+    expect(dfsInorderNodes[0].id).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).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);
+
+    const removed11 = objBST.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);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+
+    expect(node15 && objBST.getHeight(node15)).toBe(2);
+
+    const removed1 = objBST.remove(1, true);
+    expect(removed1).toBeInstanceOf(Array);
+    expect(removed1[0]).toBeDefined();
+    expect(removed1[0].deleted).toBeDefined();
+    if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed4 = objBST.remove(4, true);
+    expect(removed4).toBeInstanceOf(Array);
+    expect(removed4[0]).toBeDefined();
+    expect(removed4[0].deleted).toBeDefined();
+    if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed10 = objBST.remove(10, true);
+    expect(removed10).toBeInstanceOf(Array);
+    expect(removed10[0]).toBeDefined();
+    expect(removed10[0].deleted).toBeDefined();
+    if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed15 = objBST.remove(15, true);
+    expect(removed15).toBeInstanceOf(Array);
+    expect(removed15[0]).toBeDefined();
+    expect(removed15[0].deleted).toBeDefined();
+    if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed5 = objBST.remove(5, true);
+    expect(removed5).toBeInstanceOf(Array);
+    expect(removed5[0]).toBeDefined();
+    expect(removed5[0].deleted).toBeDefined();
+    if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed13 = objBST.remove(13, true);
+    expect(removed13).toBeInstanceOf(Array);
+    expect(removed13[0]).toBeDefined();
+    expect(removed13[0].deleted).toBeDefined();
+    if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed3 = objBST.remove(3, true);
+    expect(removed3).toBeInstanceOf(Array);
+    expect(removed3[0]).toBeDefined();
+    expect(removed3[0].deleted).toBeDefined();
+    if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed8 = objBST.remove(8, true);
+    expect(removed8).toBeInstanceOf(Array);
+    expect(removed8[0]).toBeDefined();
+    expect(removed8[0].deleted).toBeDefined();
+    if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed6 = objBST.remove(6, true);
+    expect(removed6).toBeInstanceOf(Array);
+    expect(removed6[0]).toBeDefined();
+    expect(removed6[0].deleted).toBeDefined();
+    if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+    expect(objBST.remove(6, true).length).toBe(0);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed7 = objBST.remove(7, true);
+    expect(removed7).toBeInstanceOf(Array);
+    expect(removed7[0]).toBeDefined();
+    expect(removed7[0].deleted).toBeDefined();
+    if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed9 = objBST.remove(9, true);
+    expect(removed9).toBeInstanceOf(Array);
+    expect(removed9[0]).toBeDefined();
+    expect(removed9[0].deleted).toBeDefined();
+    if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed14 = objBST.remove(14, true);
+    expect(removed14).toBeInstanceOf(Array);
+    expect(removed14[0]).toBeDefined();
+    expect(removed14[0].deleted).toBeDefined();
+    if (removed14[0].deleted) expect(removed14[0].deleted.id).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');
+    expect(bfsNodes[0].id).toBe(2);
+    expect(bfsNodes[1].id).toBe(12);
+    expect(bfsNodes[2].id).toBe(16);
+
+  });
+});

package/test/integration/heap.test.js

@@ -0,0 +1,19 @@
+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,44 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>CDN Test</title>
+  <script src="https://cdn.jsdelivr.net/npm/data-structure-typed/umd/bundle.min.js"></script>
+</head>
+<body>
+<div id="app">
+  <ul class="modules">
+
+  </ul>
+</div>
+<script defer>
+  const $modules = document.querySelector('.modules');
+  const $avlTree = document.createElement('li');
+  const $avlTreeSpan = document.createElement('span');
+  $avlTreeSpan.innerText = 'AVLTree';
+  $avlTree.append($avlTreeSpan);
+  const {AVLTree, Queue} = dataStructureTyped;
+  const avlTree = new AVLTree();
+
+  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)
+</script>
+
+</body>
+</html>
+

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

@@ -0,0 +1,111 @@
+import {AVLTree} from '../../../../src';
+
+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 getNodeById = tree.get(10, 'id');
+    expect(getNodeById?.id).toBe(10);
+
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.id).toBe(1);
+
+    const node15 = tree.get(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.id).toBe(12);
+
+    const subTreeSum = node15 && tree.subTreeSum(node15);
+    expect(subTreeSum).toBe(70);
+
+    const lesserSum = tree.lesserSum(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?.val).toBe(15);
+
+    const dfs = tree.DFS('in', 'node');
+    expect(dfs[0].id).toBe(1);
+    expect(dfs[dfs.length - 1].id).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(tree.remove(11, true)[0].deleted?.id).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.remove(1, true)[0].deleted?.id).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.remove(4, true)[0].deleted?.id).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.remove(10, true)[0].deleted?.id).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(15, true)[0].deleted?.id).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(5, true)[0].deleted?.id).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(13, true)[0].deleted?.id).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(3, true)[0].deleted?.id).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(8, true)[0].deleted?.id).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.remove(6, true)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6, true).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.remove(7, true)[0].deleted?.id).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.remove(9, true)[0].deleted?.id).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.remove(14, true)[0].deleted?.id).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');
+    expect(lastBFSNodes[0].id).toBe(12);
+    expect(lastBFSNodes[1].id).toBe(2);
+    expect(lastBFSNodes[2].id).toBe(16);
+  });
+});