data-structure-typed 1.53.9 → 1.54.1

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

@@ -1,875 +1,573 @@
-import { AVLTreeMultiMap, AVLTreeMultiMapNode, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
-import { isDebugTest } from '../../../config';
+import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../../src';
+// import { isDebugTest } from '../../../config';
 
-const isDebug = isDebugTest;
+// const isDebug = isDebugTest;
 
-describe('AVLTreeMultiMap count', () => {
-  let tm: AVLTreeMultiMap<number>;
+describe('AVLTreeMultiMap', () => {
+  let avlTmm: AVLTreeMultiMap<number, number>;
   beforeEach(() => {
-    tm = new AVLTreeMultiMap<number>();
-  });
-  it('Should added isolated node count ', () => {
-    tm.addMany([
-      [1, 1],
-      [2, 2],
-      [3, 3],
-      [4, 4],
-      [5, 5]
-    ]);
-    const newNode = new AVLTreeMultiMapNode(3, 33, 10);
-    tm.add(newNode);
-    expect(tm.count).toBe(15);
+    avlTmm = new AVLTreeMultiMap<number, number>();
   });
 
-  it('Should count', () => {
-    tm.addMany([
-      [1, 1],
-      [2, 2],
-      [3, 3]
-    ]);
-    tm.add([2, 2], undefined, 10);
-    tm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 1);
-    tm.delete(2);
-    expect(tm.count).toBe(12);
-    expect(tm.getComputedCount()).toBe(16);
+  it('Should add and delete values', () => {
+    avlTmm.add(3, 3);
+    avlTmm.add(3, 33);
+    avlTmm.add(3, 333);
+    expect(avlTmm.get(3)).toEqual([3, 33, 333]);
+    avlTmm.deleteValue(3, 33);
+    expect(avlTmm.get(3)).toEqual([3, 333]);
+    avlTmm.deleteValue(3, 3);
+    expect(avlTmm.get(3)).toEqual([333]);
+    avlTmm.deleteValue(3, 333);
+    expect(avlTmm.get(3)).toBe(undefined);
+    avlTmm.add(3, 3);
+    avlTmm.add([3, [3333, 33333]]);
+    expect(avlTmm.get(3)).toEqual([3, 3333, 33333]);
   });
 });
 
-describe('AVLTreeMultiMap operations test1', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>();
-
-    expect(treeMultimap instanceof AVLTreeMultiMap);
-    treeMultimap.add([11, 11]);
-    treeMultimap.add([3, 3]);
-    const idAndValues: [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]
-    ];
-    treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root instanceof AVLTreeMultiMapNode);
-
-    if (treeMultimap.root) expect(treeMultimap.root.key == 11);
-
-    expect(treeMultimap.size).toBe(16);
-    expect(treeMultimap.count).toBe(18);
-
-    expect(treeMultimap.has(6));
-
-    expect(treeMultimap.getHeight(6)).toBe(4);
-    expect(treeMultimap.getDepth(6)).toBe(0);
-    const nodeId10 = treeMultimap.getNode(10);
-    expect(nodeId10?.key).toBe(10);
-
-    const nodeVal9 = treeMultimap.getNode(node => node.key === 9);
-    expect(nodeVal9?.key).toBe(9);
-
-    const nodesByCount1 = treeMultimap.getNodes(node => node.count === 1);
-    expect(nodesByCount1.length).toBe(14);
-
-    const nodesByCount2 = treeMultimap.getNodes(node => node.count === 2);
-    expect(nodesByCount2.length).toBe(2);
-    const leftMost = treeMultimap.getLeftMost();
-    expect(leftMost).toBe(1);
-
-    const node15 = treeMultimap.getNode(15);
-    const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node => node, node15);
-    expect(minNodeBySpecificNode?.key).toBe(15);
+describe('AVLTreeMultiMap Test', () => {
+  it('should perform various operations on a AVLTreeMultiMap', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const avlTmm = new AVLTreeMultiMap<number>();
+
+    for (const i of arr) avlTmm.add([i, [i]]);
+
+    avlTmm.add(null);
+    const node6 = avlTmm.getNode(6);
+
+    expect(node6 && avlTmm.getHeight(node6)).toBe(3);
+    expect(node6 && avlTmm.getDepth(node6)).toBe(1);
+
+    const getNodeById = avlTmm.getNode(10);
+    expect(getNodeById?.key).toBe(10);
+
+    const getMinNodeByRoot = avlTmm.getLeftMost();
+    expect(getMinNodeByRoot).toBe(1);
+
+    const node15 = avlTmm.getNode(15);
+    const getMinNodeBySpecificNode = node15 && avlTmm.getLeftMost(node => node, node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
-    expect(subTreeSum).toBe(31);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    expect(subTreeSum).toBe(70);
+
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
+    avlTmm.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
-    expect(node15 instanceof AVLTreeMultiMapNode);
-    if (node15 instanceof AVLTreeMultiMapNode) {
-      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'PRE', 15);
-      expect(subTreeAdd);
-    }
-    const node11 = treeMultimap.getNode(11);
-    expect(node11 instanceof AVLTreeMultiMapNode);
-    if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
-      expect(allGreaterNodesAdded);
-    }
-
-    const dfsInorderNodes = treeMultimap.dfs(node => node, 'IN');
-    expect(dfsInorderNodes[0].key).toBe(1);
-    expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
-    expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
-
-    treeMultimap.perfectlyBalance();
-
-    expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    const bfsNodesAfterBalanced = treeMultimap.bfs(node => node);
-    expect(bfsNodesAfterBalanced[0].key).toBe(8);
-    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
-
-    const removed11 = treeMultimap.delete(11, true);
-    expect(removed11 instanceof Array);
-    expect(removed11[0]);
-    expect(removed11[0].deleted);
-
-    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight(15)).toBe(1);
-
-    const removed1 = treeMultimap.delete(1, true);
-    expect(removed1 instanceof Array);
-    expect(removed1[0]);
-    expect(removed1[0].deleted);
-    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight()).toBe(4);
-
-    const removed4 = treeMultimap.delete(4, true);
-    expect(removed4 instanceof Array);
-    expect(removed4[0]);
-    expect(removed4[0].deleted);
-    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(4);
-
-    const removed10 = treeMultimap.delete(10, true);
-    expect(removed10 instanceof Array);
-    expect(removed10[0]);
-    expect(removed10[0].deleted);
-    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed15 = treeMultimap.delete(15, true);
-    expect(removed15 instanceof Array);
-    expect(removed15[0]);
-    expect(removed15[0].deleted);
-    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed5 = treeMultimap.delete(5, true);
-    expect(removed5 instanceof Array);
-    expect(removed5[0]);
-    expect(removed5[0].deleted);
-    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed13 = treeMultimap.delete(13, true);
-    expect(removed13 instanceof Array);
-    expect(removed13[0]);
-    expect(removed13[0].deleted);
-    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed3 = treeMultimap.delete(3, true);
-    expect(removed3 instanceof Array);
-    expect(removed3[0]);
-    expect(removed3[0].deleted);
-    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed8 = treeMultimap.delete(8, true);
-    expect(removed8 instanceof Array);
-    expect(removed8[0]);
-    expect(removed8[0].deleted);
-    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed6 = treeMultimap.delete(6, true);
-    expect(removed6 instanceof Array);
-    expect(removed6[0]);
-    expect(removed6[0].deleted);
-    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    expect(treeMultimap.delete(6, true).length).toBe(0);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight()).toBe(2);
-
-    const removed7 = treeMultimap.delete(7, true);
-    expect(removed7 instanceof Array);
-    expect(removed7[0]);
-    expect(removed7[0].deleted);
-    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(2);
-
-    const removed9 = treeMultimap.delete(9, true);
-    expect(removed9 instanceof Array);
-    expect(removed9[0]);
-    expect(removed9[0].deleted);
-    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(2);
-
-    const removed14 = treeMultimap.delete(14, true);
-    expect(removed14 instanceof Array);
-    expect(removed14[0]);
-    expect(removed14[0].deleted);
-    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(1);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    const bfsIDs = treeMultimap.bfs(node => node.key);
-
-    expect(bfsIDs[0]).toBe(12);
-    expect(bfsIDs[1]).toBe(2);
-    expect(bfsIDs[2]).toBe(16);
-
-    const bfsNodes = treeMultimap.bfs(node => node);
-
-    expect(bfsNodes[0].key).toBe(12);
-    expect(bfsNodes[1].key).toBe(2);
-    expect(bfsNodes[2].key).toBe(16);
-
-    expect(treeMultimap.count).toBe(8);
+    // 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(avlTmm.get(15)).toEqual([15]);
+    const dfs = avlTmm.dfs(node => node, 'IN');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+    avlTmm.perfectlyBalance();
+    const bfs = avlTmm.bfs(node => node);
+    expect(avlTmm.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(avlTmm.delete(avlTmm.getNode(11))[0].deleted?.key).toBe(11);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(node15 && avlTmm.getHeight(node15)).toBe(2);
+
+    expect(avlTmm.delete(1)[0].deleted?.key).toBe(1);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(4);
+
+    expect(avlTmm.delete(4)[0].deleted?.key).toBe(4);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(4);
+
+    expect(avlTmm.delete(10)[0].deleted?.key).toBe(10);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(15)[0].deleted?.key).toBe(15);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(5)[0].deleted?.key).toBe(5);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(13)[0].deleted?.key).toBe(13);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(3)[0].deleted?.key).toBe(3);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(8)[0].deleted?.key).toBe(8);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(6)[0].deleted?.key).toBe(6);
+    expect(avlTmm.delete(6).length).toBe(0);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(2);
+
+    expect(avlTmm.delete(7)[0].deleted?.key).toBe(7);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(2);
+
+    expect(avlTmm.delete(9)[0].deleted?.key).toBe(9);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(2);
+    expect(avlTmm.delete(14)[0].deleted?.key).toBe(14);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(1);
+
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    const lastBFSIds = avlTmm.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = avlTmm.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
   });
 
-  it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objAVLTreeMultiMap = new AVLTreeMultiMap<number, { key: number; keyA: number }>();
-    expect(objAVLTreeMultiMap).toBeInstanceOf(AVLTreeMultiMap);
-    objAVLTreeMultiMap.add([11, { key: 11, keyA: 11 }]);
-    objAVLTreeMultiMap.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 }]
-    ];
-
-    objAVLTreeMultiMap.addMany(values);
-
-    expect(objAVLTreeMultiMap.root).toBeInstanceOf(AVLTreeMultiMapNode);
-
-    if (objAVLTreeMultiMap.root) expect(objAVLTreeMultiMap.root.key).toBe(6);
-
-    expect(objAVLTreeMultiMap.count).toBe(16);
-
-    expect(objAVLTreeMultiMap.has(6)).toBe(true);
+  it('should add value', () => {
+    const avlTmm = new AVLTreeMultiMap<number, string>([4, 5, [1, ['1']], 2, 3]);
+    expect(avlTmm.get(1)).toEqual(['1']);
+    expect(avlTmm.getNode(1)?.value).toEqual([]);
+    avlTmm.add(1, 'a');
+    expect(avlTmm.get(1)).toEqual(['1', 'a']);
+    avlTmm.add([1, ['b']]);
+    expect(avlTmm.getNode(1)?.value).toEqual([]);
+    expect(avlTmm.get(1)).toEqual(['1', 'a', 'b']);
+    const treeMap = new AVLTreeMultiMap<number>([4, 5, [1, ['1']], 2, 3]);
+    expect(treeMap.get(1)).toEqual(['1']);
+    expect(treeMap.getNode(1)?.value).toEqual([]);
+    treeMap.add(1, 'a');
+    expect(treeMap.get(1)).toEqual(['1', 'a']);
+    treeMap.add([1, ['b']]);
+    expect(treeMap.getNode(1)?.value).toEqual([]);
+    expect(treeMap.get(1)).toEqual(['1', 'a', 'b']);
   });
 });
 
-describe('AVLTreeMultiMap operations test recursively1', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], {
-      iterationType: 'RECURSIVE'
-    });
+describe('AVLTreeMultiMap Test recursively', () => {
+  it('should perform various operations on a AVLTreeMultiMap', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
+
+    for (const i of arr) avlTmm.add([i, [i]]);
+
+    const node6 = avlTmm.getNode(6);
+
+    expect(node6 && avlTmm.getHeight(node6)).toBe(3);
+    expect(node6 && avlTmm.getDepth(node6)).toBe(1);
 
-    expect(treeMultimap instanceof AVLTreeMultiMap);
-    treeMultimap.add([11, 11]);
-    treeMultimap.add([3, 3]);
-    const idAndValues: [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]
-    ];
-    treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root).toBeInstanceOf(AVLTreeMultiMapNode);
-
-    if (treeMultimap.root) expect(treeMultimap.root.key).toBe(6);
-
-    expect(treeMultimap.size).toBe(16);
-    expect(treeMultimap.count).toBe(18);
-
-    expect(treeMultimap.has(6));
-
-    expect(treeMultimap.getHeight(6)).toBe(4);
-    expect(treeMultimap.getDepth(6)).toBe(0);
-    const nodeId10 = treeMultimap.getNode(10);
-    expect(nodeId10?.key).toBe(10);
-
-    const nodeVal9 = treeMultimap.getNode(node => node.key === 9);
-    expect(nodeVal9?.key).toBe(9);
-
-    const nodesByCount1 = treeMultimap.getNodes(node => node.count === 1);
-    expect(nodesByCount1.length).toBe(14);
-
-    const nodesByCount2 = treeMultimap.getNodes(node => node.count === 2);
-    expect(nodesByCount2.length).toBe(2);
-    const leftMost = treeMultimap.getLeftMost();
-    expect(leftMost).toBe(1);
-
-    const node15 = treeMultimap.getNode(15);
-    const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node => node, node15);
-    expect(minNodeBySpecificNode?.key).toBe(15);
+    const getNodeById = avlTmm.getNode(10);
+    expect(getNodeById?.key).toBe(10);
+
+    const getMinNodeByRoot = avlTmm.getLeftMost();
+    expect(getMinNodeByRoot).toBe(1);
+
+    const node15 = avlTmm.getNode(15);
+    const getMinNodeBySpecificNode = node15 && avlTmm.getLeftMost(node => node, node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
-    expect(subTreeSum).toBe(31);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    expect(subTreeSum).toBe(70);
+
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
+    avlTmm.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
-    expect(node15 instanceof AVLTreeMultiMapNode);
-    if (node15 instanceof AVLTreeMultiMapNode) {
-      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'PRE', 15);
-      expect(subTreeAdd);
-    }
-    const node11 = treeMultimap.getNode(11);
-    expect(node11 instanceof AVLTreeMultiMapNode);
-    if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
-      expect(allGreaterNodesAdded);
-    }
-
-    const dfsInorderNodes = treeMultimap.dfs(node => node, 'IN');
-    expect(dfsInorderNodes[0].key).toBe(1);
-    expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
-    expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
-
-    treeMultimap.perfectlyBalance();
-
-    expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    const bfsNodesAfterBalanced = treeMultimap.bfs(node => node);
-    expect(bfsNodesAfterBalanced[0].key).toBe(8);
-    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
-
-    const removed11 = treeMultimap.delete(11, true);
-    expect(removed11 instanceof Array);
-    expect(removed11[0]);
-    expect(removed11[0].deleted);
-
-    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight(15)).toBe(1);
-
-    const removed1 = treeMultimap.delete(1, true);
-    expect(removed1 instanceof Array);
-    expect(removed1[0]);
-    expect(removed1[0].deleted);
-    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight()).toBe(4);
-
-    const removed4 = treeMultimap.delete(4, true);
-    expect(removed4 instanceof Array);
-    expect(removed4[0]);
-    expect(removed4[0].deleted);
-    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(4);
-
-    const removed10 = treeMultimap.delete(10, true);
-    expect(removed10 instanceof Array);
-    expect(removed10[0]);
-    expect(removed10[0].deleted);
-    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed15 = treeMultimap.delete(15, true);
-    expect(removed15 instanceof Array);
-    expect(removed15[0]);
-    expect(removed15[0].deleted);
-    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed5 = treeMultimap.delete(5, true);
-    expect(removed5 instanceof Array);
-    expect(removed5[0]);
-    expect(removed5[0].deleted);
-    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed13 = treeMultimap.delete(13, true);
-    expect(removed13 instanceof Array);
-    expect(removed13[0]);
-    expect(removed13[0].deleted);
-    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed3 = treeMultimap.delete(3, true);
-    expect(removed3 instanceof Array);
-    expect(removed3[0]);
-    expect(removed3[0].deleted);
-    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed8 = treeMultimap.delete(8, true);
-    expect(removed8 instanceof Array);
-    expect(removed8[0]);
-    expect(removed8[0].deleted);
-    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(3);
-
-    const removed6 = treeMultimap.delete(6, true);
-    expect(removed6 instanceof Array);
-    expect(removed6[0]);
-    expect(removed6[0].deleted);
-    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    expect(treeMultimap.delete(6, true).length).toBe(0);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    expect(treeMultimap.getHeight()).toBe(2);
-
-    const removed7 = treeMultimap.delete(7, true);
-    expect(removed7 instanceof Array);
-    expect(removed7[0]);
-    expect(removed7[0].deleted);
-    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(2);
-
-    const removed9 = treeMultimap.delete(9, true);
-    expect(removed9 instanceof Array);
-    expect(removed9[0]);
-    expect(removed9[0].deleted);
-    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(2);
-
-    const removed14 = treeMultimap.delete(14, true);
-    expect(removed14 instanceof Array);
-    expect(removed14[0]);
-    expect(removed14[0].deleted);
-    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-    expect(treeMultimap.getHeight()).toBe(1);
-
-    expect(treeMultimap.isAVLBalanced()).toBe(true);
-
-    const bfsIDs = treeMultimap.bfs(node => node.key);
-
-    expect(bfsIDs[0]).toBe(12);
-    expect(bfsIDs[1]).toBe(2);
-    expect(bfsIDs[2]).toBe(16);
-
-    const bfsNodes = treeMultimap.bfs(node => node);
-
-    expect(bfsNodes[0].key).toBe(12);
-    expect(bfsNodes[1].key).toBe(2);
-    expect(bfsNodes[2].key).toBe(16);
-
-    expect(treeMultimap.count).toBe(8);
-  });
-
-  it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objAVLTreeMultiMap = new AVLTreeMultiMap<number, { key: number; keyA: number }>();
-    expect(objAVLTreeMultiMap).toBeInstanceOf(AVLTreeMultiMap);
-    objAVLTreeMultiMap.add([11, { key: 11, keyA: 11 }]);
-    objAVLTreeMultiMap.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 }]
-    ];
-
-    objAVLTreeMultiMap.addMany(values);
-
-    expect(objAVLTreeMultiMap.root).toBeInstanceOf(AVLTreeMultiMapNode);
-
-    if (objAVLTreeMultiMap.root) expect(objAVLTreeMultiMap.root.key).toBe(6);
-
-    expect(objAVLTreeMultiMap.count).toBe(16);
-
-    expect(objAVLTreeMultiMap.has(6)).toBe(true);
+    // 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(avlTmm.get(15)).toEqual([15]);
+
+    const dfs = avlTmm.dfs(node => node, 'IN');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+
+    avlTmm.perfectlyBalance();
+    const bfs = avlTmm.bfs(node => node);
+    expect(avlTmm.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(avlTmm.delete(11)[0].deleted?.key).toBe(11);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(node15 && avlTmm.getHeight(node15)).toBe(2);
+
+    expect(avlTmm.delete(1)[0].deleted?.key).toBe(1);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(4);
+
+    expect(avlTmm.delete(4)[0].deleted?.key).toBe(4);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(4);
+
+    expect(avlTmm.delete(10)[0].deleted?.key).toBe(10);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(15)[0].deleted?.key).toBe(15);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(5)[0].deleted?.key).toBe(5);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(13)[0].deleted?.key).toBe(13);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(3)[0].deleted?.key).toBe(3);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(8)[0].deleted?.key).toBe(8);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(3);
+
+    expect(avlTmm.delete(6)[0].deleted?.key).toBe(6);
+    expect(avlTmm.delete(6).length).toBe(0);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(2);
+
+    expect(avlTmm.delete(7)[0].deleted?.key).toBe(7);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(2);
+
+    expect(avlTmm.delete(9)[0].deleted?.key).toBe(9);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(2);
+    expect(avlTmm.delete(14)[0].deleted?.key).toBe(14);
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    expect(avlTmm.getHeight()).toBe(1);
+
+    expect(avlTmm.isAVLBalanced()).toBe(true);
+    const lastBFSIds = avlTmm.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = avlTmm.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
   });
 });
 
-describe('AVLTreeMultiMap Performance test', function () {
-  const treeMS = new AVLTreeMultiMap<number, number>();
-  const inputSize = 100000; // Adjust input sizes as needed
-
+describe('AVLTreeMultiMap APIs test', () => {
+  const avlTmm = new AVLTreeMultiMap<number, { id: number; text: string }>();
   beforeEach(() => {
-    treeMS.clear();
+    avlTmm.clear();
   });
 
-  it(`Observe the time consumption of AVLTreeMultiMap.dfs be good`, function () {
-    const startDFS = performance.now();
-    const dfs = treeMS.dfs(node => node);
-    if (isDebug) console.log('---bfs', performance.now() - startDFS, dfs.length);
-  });
+  it('add', () => {
+    avlTmm.add(1);
+    const node2 = new AVLTreeMultiMapNode(2, []);
+    avlTmm.add(node2);
+    const node3 = new AVLTreeMultiMapNode(3, [
+      {
+        id: 3,
+        text: 'text3'
+      }
+    ]);
+    avlTmm.add(node3);
+    avlTmm.add([3, [{ id: 3, text: 'text33' }]]);
 
-  it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
-    const start = performance.now();
-    for (let i = 0; i < inputSize; i++) {
-      treeMS.add(i);
-    }
-    if (isDebug) console.log('---add', performance.now() - start);
-    const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), -1, inputSize / 2);
-    if (isDebug) console.log('---lesserOrGreaterTraverse', performance.now() - startL);
+    const bfsRes = avlTmm.bfs(node => node.key);
+    expect(bfsRes[0]).toBe(2);
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(treeMultimap: AVLTreeMultiMap<string, number>) {
-      expect(treeMultimap.size).toBe(4);
-      expect(treeMultimap.root?.key).toBe('2');
-      expect(treeMultimap.root?.left?.key).toBe('1');
-      expect(treeMultimap.root?.left?.left?.key).toBe(undefined);
-      expect(treeMultimap.root?.left?.right?.key).toBe(undefined);
-      expect(treeMultimap.root?.right?.key).toBe('4');
-      expect(treeMultimap.root?.right?.left?.key).toBe(undefined);
-      expect(treeMultimap.root?.right?.right?.key).toBe('5');
+    function checkTreeStructure(avlTmm: AVLTreeMultiMap<string, number>) {
+      expect(avlTmm.size).toBe(4);
+      expect(avlTmm.root?.key).toBe('2');
+      expect(avlTmm.root?.left?.key).toBe('1');
+      expect(avlTmm.root?.left?.left?.key).toBe(undefined);
+      expect(avlTmm.root?.left?.right?.key).toBe(undefined);
+      expect(avlTmm.root?.right?.key).toBe('4');
+      expect(avlTmm.root?.right?.left?.key).toBe(undefined);
+      expect(avlTmm.root?.right?.right?.key).toBe('5');
     }
 
-    const treeMultimap = new AVLTreeMultiMap<string, number>();
-    treeMultimap.addMany([
+    const avlTmm = new AVLTreeMultiMap<string, number>();
+    avlTmm.addMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
       ['3', 3],
       ['1', 1]
     ]);
-    expect(treeMultimap.size).toBe(5);
-    expect(treeMultimap.root?.key).toBe('2');
-    expect(treeMultimap.root?.left?.key).toBe('1');
-    expect(treeMultimap.root?.left?.left?.key).toBe(undefined);
-    expect(treeMultimap.root?.left?.right?.key).toBe(undefined);
-    expect(treeMultimap.root?.right?.key).toBe('4');
-    expect(treeMultimap.root?.right?.left?.key).toBe('3');
-    expect(treeMultimap.root?.right?.right?.key).toBe('5');
-    treeMultimap.delete('3');
-    checkTreeStructure(treeMultimap);
-    const cloned = treeMultimap.clone();
+    expect(avlTmm.size).toBe(5);
+    expect(avlTmm.root?.key).toBe('2');
+    expect(avlTmm.root?.left?.key).toBe('1');
+    expect(avlTmm.root?.left?.left?.key).toBe(undefined);
+    expect(avlTmm.root?.left?.right?.key).toBe(undefined);
+    expect(avlTmm.root?.right?.key).toBe('4');
+    expect(avlTmm.root?.right?.left?.key).toBe('3');
+    expect(avlTmm.root?.right?.right?.key).toBe('5');
+    avlTmm.delete('3');
+    checkTreeStructure(avlTmm);
+    const cloned = avlTmm.clone();
     checkTreeStructure(cloned);
     cloned.delete('1');
-    expect(treeMultimap.size).toBe(4);
+    expect(avlTmm.size).toBe(4);
     expect(cloned.size).toBe(3);
   });
 });
 
+describe('AVLTreeMultiMap', () => {
+  it('should balance the avlTmm using _balanceLR when nodes are added', () => {
+    const avlTmm = new AVLTreeMultiMap();
+    avlTmm.add([10, 'A']);
+    avlTmm.add([5, 'B']);
+    avlTmm.add([15, 'C']);
+    avlTmm.add([3, 'D']);
+    avlTmm.add([7, 'E']);
+
+    // Adding nodes to trigger _balanceLR
+    avlTmm.add([12, 'F']);
+
+    // You can add more specific assertions to check the avlTmm's balance and structure.
+  });
+
+  it('should addMany undefined and null', () => {
+    const avlTmm = new AVLTreeMultiMap<number, string>();
+    const addManyWithUndefined = avlTmm.addMany([1, undefined, 3]);
+    expect(addManyWithUndefined).toEqual([true, false, true]);
+    expect(avlTmm.get(undefined)).toBe(undefined);
+    const addManyWithNull = avlTmm.addMany([1, null, 3, 4]);
+    expect(addManyWithNull).toEqual([true, false, true, true]);
+    const addManyEntriesWithNull = avlTmm.addMany([
+      [1, '1'],
+      [null, 'null'],
+      [3, '3'],
+      [4, '4']
+    ]);
+    expect(addManyEntriesWithNull).toEqual([true, false, true, true]);
+    expect(avlTmm.get(null)).toBe(undefined);
+    const node0 = avlTmm.add(0, '0');
+    expect(node0).toBe(true);
+    expect(avlTmm.get(0)).toEqual(['0']);
+  });
+
+  it('should balance the avlTmm using _balanceLR when nodes are deleted', () => {
+    const avlTmm = new AVLTreeMultiMap();
+    avlTmm.add([10, 'A']);
+    avlTmm.add([5, 'B']);
+    avlTmm.add([15, 'C']);
+    avlTmm.add([3, 'D']);
+    avlTmm.add([7, 'E']);
+    avlTmm.add([12, 'F']);
+
+    // Deleting nodes to trigger _balanceLR
+    avlTmm.delete(3);
+
+    // You can add more specific assertions to check the avlTmm's balance and structure.
+  });
+
+  describe('BinaryTree APIs test', () => {
+    const avlTmm = new AVLTreeMultiMap<number, { id: number; text: string }>();
+    beforeEach(() => {
+      avlTmm.clear();
+    });
+
+    it('add', () => {
+      avlTmm.add(1);
+      const node2 = new AVLTreeMultiMapNode(2, []);
+      avlTmm.add(node2);
+      const node3 = new AVLTreeMultiMapNode(3, [
+        {
+          id: 3,
+          text: 'text3'
+        }
+      ]);
+      avlTmm.add(node3);
+      avlTmm.add([3, [{ id: 3, text: 'text33' }]]);
+
+      const bfsRes = avlTmm.bfs(node => node);
+      expect(bfsRes[0]?.key).toBe(2);
+    });
+  });
+});
+
 describe('AVLTreeMultiMap iterative methods test', () => {
-  let treeMM: AVLTreeMultiMap<number, string>;
+  let avlTmm: AVLTreeMultiMap<number, string, object, string, string, object>;
   beforeEach(() => {
-    treeMM = new AVLTreeMultiMap<number, string>();
-    treeMM.add(1, 'a', 10);
-    treeMM.add([2, 'b'], undefined, 10);
-    treeMM.add([3, 'c'], undefined, 1);
+    avlTmm = new AVLTreeMultiMap();
+    avlTmm.add([1, ['a']]);
+    avlTmm.add([2, ['b']]);
+    avlTmm.add([3, ['c']]);
   });
 
   it('The node obtained by get Node should match the node type', () => {
-    const node3 = treeMM.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
-    expect(node3).toBeInstanceOf(AVLTreeNode);
+    const node3 = avlTmm.getNode(3);
+
+    expect(node3).toBeInstanceOf(AVLTreeMultiMapNode);
   });
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    treeMM.forEach((key, value) => {
+    avlTmm.forEach((key, value) => {
       mockCallback(key, value);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0]).toEqual([1, 'a']);
-    expect(mockCallback.mock.calls[1]).toEqual([2, 'b']);
-    expect(mockCallback.mock.calls[2]).toEqual([3, 'c']);
+    expect(mockCallback.mock.calls[0]).toEqual([1, ['a']]);
+    expect(mockCallback.mock.calls[1]).toEqual([2, ['b']]);
+    expect(mockCallback.mock.calls[2]).toEqual([3, ['c']]);
   });
 
-  it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = treeMM.filter(key => key > 1);
+  it('filter should return a new avlTmm with filtered elements', () => {
+    const filteredTree = avlTmm.filter(key => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
-      [2, 'b'],
-      [3, 'c']
+      [2, ['b']],
+      [3, ['c']]
     ]);
   });
 
-  it('map should return a new tree with modified elements', () => {
-    const mappedTree = treeMM.map((key, value) => [(key * 2).toString(), value]);
-    expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([
-      ['2', 'a'],
-      ['4', 'b'],
-      ['6', 'c']
+  it('map should return a new avlTmm with modified elements', () => {
+    const avlTmmMapped = avlTmm.map((key, value) => [(key * 2).toString(), value ? value :[]]);
+    expect(avlTmmMapped.size).toBe(3);
+    expect([...avlTmmMapped]).toEqual([
+      ['2', ['a']],
+      ['4', ['b']],
+      ['6', ['c']]
     ]);
   });
 
   it('reduce should accumulate values', () => {
-    const sum = treeMM.reduce((acc, value, key) => acc + key, 0);
+    const sum = avlTmm.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 
   it('[Symbol.iterator] should provide an iterator', () => {
     const entries = [];
-    for (const entry of treeMM) {
+    for (const entry of avlTmm) {
       entries.push(entry);
     }
 
     expect(entries.length).toBe(3);
     expect(entries).toEqual([
-      [1, 'a'],
-      [2, 'b'],
-      [3, 'c']
+      [1, ['a']],
+      [2, ['b']],
+      [3, ['c']]
     ]);
   });
 
   it('should clone work well', () => {
-    expect(treeMM.count).toBe(21);
-    const cloned = treeMM.clone();
+    const cloned = avlTmm.clone();
     expect(cloned.root?.left?.key).toBe(1);
-    expect(cloned.get(cloned.root?.right)).toBe('c');
+    expect(cloned.root?.right?.value).toEqual([]);
   });
 
   it('should keys', () => {
-    const keys = treeMM.keys();
+    const keys = avlTmm.keys();
     expect([...keys]).toEqual([1, 2, 3]);
   });
 
   it('should values', () => {
-    const values = treeMM.values();
-    expect([...values]).toEqual(['a', 'b', 'c']);
+    const values = avlTmm.values();
+    expect([...values]).toEqual([['a'], ['b'], ['c']]);
+  });
+
+  it('should leaves', () => {
+    const leaves = avlTmm.leaves();
+    expect(leaves).toEqual([1, 3]);
   });
 });
 
-describe('AVLTree toEntryFn', () => {
-  it('should toEntryFn 1', () => {
-    const tree = new AVLTreeMultiMap<number, number, { obj: { id: number } }>([], {
-      toEntryFn: ele => [ele.obj.id, ele.obj.id]
-    });
-    tree.add({ obj: { id: 1 } });
-    tree.add({ obj: { id: 2 } });
-    tree.add({ obj: { id: 3 } });
-    tree.add({ obj: { id: 4 } });
-    tree.add({ obj: { id: 5 } });
+describe('AVLTreeMultiMap not map mode', () => {
+  it('should perform various operations on a AVLTreeMultiMap', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const avlTmm = new AVLTreeMultiMap<number>([]);
 
-    const expected = [1, 2, 3, 4, 5];
+    for (const i of arr) avlTmm.add([i, [i]]);
 
-    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
-  });
+    avlTmm.add(null);
+    const node6 = avlTmm.getNode(6);
 
-  it('should toEntryFn 2', () => {
-    const tree = new AVLTreeMultiMap<number, number, { obj: { id: number } }>(
-      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
-      {
-        toEntryFn: ele => [ele.obj.id, ele.obj.id]
-      }
-    );
+    expect(node6 && avlTmm.getHeight(node6)).toBe(3);
+    expect(node6 && avlTmm.getDepth(node6)).toBe(1);
 
-    const expected = [1, 2, 3, 4, 5];
+    const getNodeById = avlTmm.getNode(10);
+    expect(getNodeById?.key).toBe(10);
 
-    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
-  });
+    const getMinNodeByRoot = avlTmm.getLeftMost();
+    expect(getMinNodeByRoot).toBe(1);
 
-  it('should toEntryFn throw error', () => {
-    expect(
-      () =>
-        new AVLTreeMultiMap<{ obj: { id: number } }, number>([
-          { obj: { id: 1 } },
-          { obj: { id: 2 } },
-          { obj: { id: 3 } },
-          { obj: { id: 4 } },
-          { obj: { id: 5 } }
-        ])
-    ).toThrowError(
-      `When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`
-    );
-  });
+    const node15 = avlTmm.getNode(15);
+    const getMinNodeBySpecificNode = node15 && avlTmm.getLeftMost(node => node, node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
 
-  it('should toEntryFn 3', () => {
-    const tree = new AVLTreeMultiMap<{ obj: { id: number } }, number>(
-      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
-      {
-        specifyComparable: key => key.obj.id
-      }
-    );
-
-    const expected = [
-      { obj: { id: 1 } },
-      { obj: { id: 2 } },
-      { obj: { id: 3 } },
-      { obj: { id: 4 } },
-      { obj: { id: 5 } }
-    ];
-
-    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
-  });
-});
+    let subTreeSum = 0;
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    expect(subTreeSum).toBe(70);
 
-describe('AVLTreeMultiMap not map mode count', () => {
-  let tm: AVLTreeMultiMap<number>;
-  beforeEach(() => {
-    tm = new AVLTreeMultiMap<number>([], { isMapMode: false });
-  });
-  it('Should added isolated node count ', () => {
-    tm.addMany([
-      [1, 1],
-      [2, 2],
-      [3, 3],
-      [4, 4],
-      [5, 5]
-    ]);
-    const newNode = new AVLTreeMultiMapNode(3, undefined, 10);
-    tm.add(newNode, 33);
-    expect(tm.count).toBe(15);
+    let lesserSum = 0;
+    avlTmm.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(avlTmm.get(node15)).toEqual([15]);
   });
 });
 
-describe('AVLTreeMultiMap not map mode operations test1', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], { isMapMode: false });
-
-    expect(treeMultimap instanceof AVLTreeMultiMap);
-    treeMultimap.add([11, 11]);
-    treeMultimap.add([3, 3]);
-    const idAndValues: [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]
-    ];
-    treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root instanceof AVLTreeMultiMapNode);
-
-    if (treeMultimap.root) expect(treeMultimap.root.key == 11);
-
-    expect(treeMultimap.size).toBe(16);
-    expect(treeMultimap.count).toBe(18);
-
-    expect(treeMultimap.has(6));
-
-    expect(treeMultimap.getHeight(6)).toBe(4);
-    expect(treeMultimap.getDepth(6)).toBe(0);
-    const nodeId10 = treeMultimap.getNode(10);
-    expect(nodeId10?.key).toBe(10);
-
-    const nodeVal9 = treeMultimap.getNode(node => node.key === 9);
-    expect(nodeVal9?.key).toBe(9);
+describe('AVLTreeMultiMap not map mode test recursively', () => {
+  it('should perform various operations on a AVLTreeMultiMap', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
+
+    for (const i of arr) avlTmm.add([i, [i]]);
+
+    const node6 = avlTmm.getNode(6);
+
+    expect(node6 && avlTmm.getHeight(node6)).toBe(3);
+    expect(node6 && avlTmm.getDepth(node6)).toBe(1);
+
+    const getNodeById = avlTmm.getNode(10);
+    expect(getNodeById?.key).toBe(10);
+
+    const getMinNodeByRoot = avlTmm.getLeftMost();
+    expect(getMinNodeByRoot).toBe(1);
+
+    const node15 = avlTmm.getNode(15);
+    const getMinNodeBySpecificNode = node15 && avlTmm.getLeftMost(node => node, node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    avlTmm.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(avlTmm.get(node15)).toEqual([15]);
   });
 });
 
-describe('AVLTreeMultiMap not map mode operations test recursively1', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], {
-      iterationType: 'RECURSIVE',
-      isMapMode: false
-    });
+describe('AVLTreeMultiMap iterative methods not map mode', () => {
+  let avlTmm: AVLTreeMultiMap<number, string>;
+  beforeEach(() => {
+    avlTmm = new AVLTreeMultiMap<number, string>([]);
+    avlTmm.add([1, ['a']]);
+    avlTmm.add([2, ['b']]);
+    avlTmm.add([3, ['c']]);
+  });
 
-    expect(treeMultimap instanceof AVLTreeMultiMap);
-    treeMultimap.add([11, 11]);
-    treeMultimap.add([3, 3]);
-    const idAndValues: [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]
-    ];
-    treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root).toBeInstanceOf(AVLTreeMultiMapNode);
-
-    if (treeMultimap.root) expect(treeMultimap.root.key).toBe(6);
-
-    expect(treeMultimap.size).toBe(16);
-    expect(treeMultimap.count).toBe(18);
-
-    expect(treeMultimap.has(6));
-
-    expect(treeMultimap.getHeight(6)).toBe(4);
-    expect(treeMultimap.getDepth(6)).toBe(0);
-    const nodeId10 = treeMultimap.getNode(10);
-    expect(nodeId10?.key).toBe(10);
-
-    const nodeVal9 = treeMultimap.getNode(node => node.key === 9);
-    expect(nodeVal9?.key).toBe(9);
+  it('should clone work well', () => {
+    const cloned = avlTmm.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.get(cloned.root?.right?.key)).toEqual(['c']);
   });
 });