data-structure-typed 2.4.0 → 2.4.2

package/eslint.config.mjs

@@ -1,73 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import _import from "eslint-plugin-import";
-import { fixupPluginRules } from "@eslint/compat";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all
-});
-
-export default [{
-  ignores: ["**/lib/", "**/dist/", "**/umd/", "**/coverage/", "**/docs/"],
-}, ...compat.extends("plugin:@typescript-eslint/recommended", "prettier"), {
-  plugins: {
-    "@typescript-eslint": typescriptEslint,
-    import: fixupPluginRules(_import),
-  },
-
-  languageOptions: {
-    parser: tsParser,
-  },
-
-  settings: {
-    "import/parsers": {
-      "@typescript-eslint/parser": [".ts"],
-    },
-
-    "import/resolver": {
-      typescript: {
-        alwaysTryTypes: true,
-        project: ["./tsconfig.json"],
-      },
-    },
-  },
-
-  rules: {
-    "import/no-anonymous-default-export": "off",
-    "@typescript-eslint/no-unused-vars": ["warn", { 
-      "argsIgnorePattern": "^_",
-      "varsIgnorePattern": "^_",
-      "caughtErrorsIgnorePattern": "^_"
-    }],
-    "@typescript-eslint/ban-ts-comment": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-var-requires": "off",
-    "@typescript-eslint/no-non-null-assertion": "off",
-    "@typescript-eslint/no-require-imports": "off",
-    "lines-around-comment": ["warn", {
-      beforeLineComment: false,
-      beforeBlockComment: true,
-      allowBlockStart: true,
-      allowClassStart: true,
-      allowObjectStart: true,
-      allowArrayStart: true,
-    }],
-
-    "newline-before-return": "off",
-
-    "import/newline-after-import": ["warn", {
-      count: 1,
-    }],
-
-
-    "object-curly-spacing": ["warn", "always"],
-  },
-}];

package/test/config.ts

@@ -1,4 +0,0 @@
-export const isDebugTest = false;
-export const isCompetitor = false;
-export const isTestStackOverflow = false;
-export const SYSTEM_MAX_CALL_STACK = 12000;

package/test/integration/all-in-one.test.ts

@@ -1,110 +0,0 @@
-import { AVLTree } from 'data-structure-typed';
-
-describe('AVL Tree Test from data-structure-typed', () => {
-  it('should perform various operations on a AVL Tree from data-structure-typed', () => {
-    const keys = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>([], { isMapMode: false });
-
-    for (const i of keys) 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).toBe(1);
-
-    const node15 = tree.getNode(15);
-    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node => node, node15);
-    expect(getMinNodeBySpecificNode?.key).toBe(12);
-
-    let subTreeSum = 0;
-    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
-    expect(subTreeSum).toBe(70);
-
-    let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 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(1);
-
-    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/avl-tree.test.ts

@@ -1,127 +0,0 @@
-import { AVLTree } from 'avl-tree-typed';
-
-describe('AVL Tree Test', () => {
-  it('should perform various operations on a AVL Tree', () => {
-    const arr: [number, number][] = [
-      [11, 11],
-      [3, 3],
-      [15, 15],
-      [1, 1],
-      [8, 8],
-      [13, 13],
-      [16, 16],
-      [2, 2],
-      [6, 6],
-      [9, 9],
-      [12, 12],
-      [14, 14],
-      [4, 4],
-      [7, 7],
-      [10, 10],
-      [5, 5]
-    ];
-    const tree = new AVLTree<number, number>();
-
-    for (const i of arr) tree.add(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).toBe(1);
-
-    const node15 = tree.getNode(15);
-    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node => node, node15);
-    expect(getMinNodeBySpecificNode?.key).toBe(12);
-
-    let subTreeSum = 0;
-    if (node15) tree.dfs(node => (subTreeSum += node.key), 'IN', false, 15);
-    expect(subTreeSum).toBe(70);
-
-    let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 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(undefined);
-
-    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

@@ -1,385 +0,0 @@
-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<number>();
-    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, undefined);
-    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(bst.getHeight(node6)).toBe(5);
-    expect(bst.getDepth(6)).toBe(4);
-
-    const nodeId10 = bst.getNode(10);
-    expect(nodeId10?.key).toBe(10);
-
-    const nodeVal9 = bst.getNode(node => node.value === 9);
-    expect(nodeVal9?.key).toBe(undefined);
-
-    const nodeVal11 = bst.getNode(node => node.value === 11);
-    expect(nodeVal11?.key).toBe(undefined);
-
-    const leftMost = bst.getLeftMost(node => node);
-    expect(leftMost?.key).toBe(1);
-
-    const node15 = bst.getNode(15);
-    const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
-    expect(minNodeBySpecificNode?.key).toBe(14);
-
-    let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'IN', false, 15);
-    expect(subTreeSum).toBe(45);
-
-    let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 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<number, { key: number; keyA: number }>([], { isMapMode: false });
-    expect(objBST).toBeInstanceOf(BST);
-    objBST.add([11, { key: 11, keyA: 11 }]);
-    objBST.add([3, { key: 3, keyA: 3 }]);
-    const values: [number, { key: number; keyA: number }][] = [
-      [15, { key: 15, keyA: 15 }],
-      [1, { key: 1, keyA: 1 }],
-      [8, { key: 8, keyA: 8 }],
-      [13, { key: 13, keyA: 13 }],
-      [16, { key: 16, keyA: 16 }],
-      [2, { key: 2, keyA: 2 }],
-      [6, { key: 6, keyA: 6 }],
-      [9, { key: 9, keyA: 9 }],
-      [12, { key: 12, keyA: 12 }],
-      [14, { key: 14, keyA: 14 }],
-      [4, { key: 4, keyA: 4 }],
-      [7, { key: 7, keyA: 7 }],
-      [10, { key: 10, keyA: 10 }],
-      [5, { key: 5, keyA: 5 }]
-    ];
-
-    objBST.addMany(values, undefined);
-
-    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(objBST.getHeight(node6)).toBe(1);
-    expect(objBST.getDepth(node6)).toBe(4);
-
-    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).toBe(1);
-
-    const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({
-      key: 15,
-      keyA: 15
-    });
-    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node => node, node15);
-    expect(minNodeBySpecificNode?.key).toBe(14);
-
-    let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'IN', false, node15);
-    expect(subTreeSum).toBe(45);
-
-    let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 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(1);
-
-    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);
-  });
-});