data-structure-typed 1.52.8 → 1.53.0

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

@@ -678,7 +678,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
     expect(treeMM.count).toBe(21);
     const cloned = treeMM.clone();
     expect(cloned.root?.left?.key).toBe(1);
-    expect(cloned.root?.right?.value).toBe('c');
+    expect(cloned.get(cloned.root?.right)).toBe('c');
   });
 
   it('should keys', () => {
@@ -761,3 +761,115 @@ describe('AVLTree toEntryFn', () => {
     expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
   });
 });
+
+describe('AVLTreeMultiMap map mode count', () => {
+  let tm: AVLTreeMultiMap<number>;
+  beforeEach(() => {
+    tm = new AVLTreeMultiMap<number>([], { isMapMode: true });
+  });
+  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);
+  });
+});
+
+describe('AVLTreeMultiMap map mode operations test1', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
+    const treeMultimap = new AVLTreeMultiMap<number>([], { isMapMode: true });
+
+    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 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: true
+    });
+
+    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);
+  });
+});

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

@@ -33,7 +33,6 @@ describe('AVL Tree Test', () => {
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.value).toBe(15);
-
     const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
@@ -292,6 +291,26 @@ describe('AVLTree', () => {
     // You can add more specific assertions to check the tree's balance and structure.
   });
 
+  it('should addMany undefined and null', () => {
+    const avl = new AVLTree<number, string>();
+    const addManyWithUndefined = avl.addMany([1, undefined, 3]);
+    expect(addManyWithUndefined).toEqual([true, false, true]);
+    expect(avl.get(undefined)).toBe(undefined);
+    const addManyWithNull = avl.addMany([1, null, 3, 4]);
+    expect(addManyWithNull).toEqual([true, false, true, true]);
+    const addManyEntriesWithNull = avl.addMany([
+      [1, '1'],
+      [null, 'null'],
+      [3, '3'],
+      [4, '4']
+    ]);
+    expect(addManyEntriesWithNull).toEqual([true, false, true, true]);
+    expect(avl.get(null)).toBe(undefined);
+    const node0 = avl.add(0, '0');
+    expect(node0).toBe(true);
+    expect(avl.get(0)).toBe('0');
+  });
+
   it('should balance the tree using _balanceLR when nodes are deleted', () => {
     const avlTree = new AVLTree();
     avlTree.add([10, 'A']);
@@ -417,3 +436,90 @@ describe('AVLTree iterative methods test', () => {
     expect(leaves).toEqual([1, 3]);
   });
 });
+
+describe('AVL Tree map mode', () => {
+  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<number>([], { isMapMode: true });
+
+    for (const i of arr) tree.add([i, i]);
+
+    tree.add(null);
+    const node6 = tree.getNode(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getNodeById = tree.getNode(10);
+    expect(getNodeById?.key).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', node15);
+    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(tree.get(node15)).toBe(15);
+  });
+});
+
+describe('AVL Tree map mode test recursively', () => {
+  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<number>([], { iterationType: 'RECURSIVE', isMapMode: true });
+
+    for (const i of arr) tree.add([i, i]);
+
+    const node6 = tree.getNode(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getNodeById = tree.getNode(10);
+    expect(getNodeById?.key).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', node15);
+    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(tree.get(node15)).toBe(15);
+  });
+});
+
+describe('AVLTree iterative methods map mode', () => {
+  let avl: AVLTree<number, string>;
+  beforeEach(() => {
+    avl = new AVLTree<number, string>([], { isMapMode: true });
+    avl.add([1, 'a']);
+    avl.add([2, 'b']);
+    avl.add([3, 'c']);
+  });
+
+  it('should clone work well', () => {
+    const cloned = avl.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.get(cloned.root?.right?.key)).toBe('c');
+  });
+});

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

@@ -20,6 +20,8 @@ describe('BinaryTreeNode', () => {
 
   it('should set and get the value correctly', () => {
     const node: BinaryTreeNode<number> = new BinaryTreeNode<number>(1, 42);
+    expect(node.key).toBe(1);
+
     expect(node.value).toBe(42);
 
     node.value = 55;
@@ -105,6 +107,27 @@ describe('BinaryTree addMany', () => {
     expect(tree.getNodeByKey(4)?.value).toBe(44);
     expect(tree.getNodeByKey(1)?.value).toBe(1);
   });
+
+  it('should addMany undefined and null', () => {
+    const binaryTree = new BinaryTree<number, string>();
+    const addManyWithUndefined = binaryTree.addMany([1, undefined, 3]);
+    expect(addManyWithUndefined).toEqual([true, false, true]);
+    expect(binaryTree.get(undefined)).toBe(undefined);
+    const addManyWithNull = binaryTree.addMany([1, null, 3, 4]);
+    expect(addManyWithNull).toEqual([true, true, true, true]);
+    const addManyEntriesWithNull = binaryTree.addMany([
+      [1, '1'],
+      [null, 'null'],
+      [3, '3'],
+      [4, '4']
+    ]);
+    expect(addManyEntriesWithNull).toEqual([true, true, true, true]);
+    expect(binaryTree.get(null)).toBe(undefined);
+    expect(binaryTree.getNode(null)).toBe(null);
+    const node0 = binaryTree.add(0, '0');
+    expect(node0).toBe(true);
+    expect(binaryTree.get(0)).toBe('0');
+  });
 });
 
 describe('BinaryTree', () => {
@@ -299,7 +322,8 @@ describe('BinaryTree', () => {
     expect(tree.toVisual()).toBe('');
     tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
     expect(tree.toVisual()).toBe(
-      '    ___4___    \n' +
+      'N for null\n' +
+        '    ___4___    \n' +
         '   /       \\   \n' +
         '  _2_     _6_  \n' +
         ' /   \\   /   \\ \n' +
@@ -309,9 +333,9 @@ describe('BinaryTree', () => {
     const visualized = tree.toVisual(undefined, { isShowUndefined: true, isShowNull: true, isShowRedBlackNIL: true });
     expect(visualized).toBe(
       'U for undefined\n' +
-        '      N for null\n' +
-        '      S for Sentinel Node(NIL)\n' +
-        '              _______4_______        \n' +
+        'N for null\n' +
+        'S for Sentinel Node(NIL)\n' +
+        '        _______4_______        \n' +
         '       /               \\       \n' +
         '    ___2___         ___6___    \n' +
         '   /       \\       /       \\   \n' +
@@ -709,34 +733,40 @@ describe('BinaryTree', () => {
     ]);
   });
 
-  it('should keyValueOrEntryOrRawElementToNode', () => {
+  it('should keyValueNodeEntryRawToNodeAndValue', () => {
     const tree = new BinaryTree<number>();
-    const node0 = tree.keyValueOrEntryOrRawElementToNode(0);
-    expect(node0).toEqual({
-      _left: undefined,
-      _right: undefined,
-      key: 0,
-      parent: undefined,
-      value: undefined
-    });
+    const node0 = tree.keyValueNodeEntryRawToNodeAndValue(0);
+    expect(node0).toEqual([
+      {
+        _left: undefined,
+        _right: undefined,
+        key: 0,
+        parent: undefined,
+        value: undefined
+      },
+      undefined
+    ]);
 
-    const nodeUndefined = tree.keyValueOrEntryOrRawElementToNode(undefined);
-    expect(nodeUndefined).toBe(undefined);
+    const nodeUndefined = tree.keyValueNodeEntryRawToNodeAndValue(undefined);
+    expect(nodeUndefined).toEqual([undefined, undefined]);
 
-    const nodeNull = tree.keyValueOrEntryOrRawElementToNode(null);
-    expect(nodeNull).toBe(null);
+    const nodeNull = tree.keyValueNodeEntryRawToNodeAndValue(null);
+    expect(nodeNull).toEqual([null, undefined]);
 
-    const nodeWithSeparateValue = tree.keyValueOrEntryOrRawElementToNode(7, 77);
-    expect(nodeWithSeparateValue?.value).toBe(77);
+    const [, nodeWithSeparateValue] = tree.keyValueNodeEntryRawToNodeAndValue(7, 77);
+    expect(nodeWithSeparateValue).toBe(77);
 
-    expect(tree.keyValueOrEntryOrRawElementToNode([undefined, 2])).toBe(undefined);
+    expect(tree.keyValueNodeEntryRawToNodeAndValue([undefined, 2])).toEqual([undefined, undefined]);
 
-    expect(tree.keyValueOrEntryOrRawElementToNode(Symbol('test') as unknown as number)).toBe(undefined);
+    expect(tree.keyValueNodeEntryRawToNodeAndValue(Symbol('test') as unknown as number)).toEqual([
+      undefined,
+      undefined
+    ]);
 
     const bTree = new BinaryTree<number, number, { obj: { id: number } }>([], {
       toEntryFn: (ele: { obj: { id: number } }) => [Symbol('test') as unknown as number, ele.obj.id]
     });
-    expect(bTree.keyValueOrEntryOrRawElementToNode({ obj: { id: 1 } })).toBe(undefined);
+    expect(bTree.keyValueNodeEntryRawToNodeAndValue({ obj: { id: 1 } })).toEqual([undefined, undefined]);
   });
 });
 
@@ -1130,17 +1160,21 @@ describe('BinaryTree', () => {
     tree.add([2, 'B']);
     tree.add([null, 'null']);
 
-    const nodes = tree.getNodes(node => node.value === 'B');
+    const nodes = tree.isMapMode ? tree.getNodes(node => node.key === 2) : tree.getNodes(node => node.value === 'B');
 
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(2);
 
-    const nodesRec = tree.getNodes(node => node.value === 'B', false, tree.root, 'RECURSIVE');
+    const nodesRec = tree.isMapMode
+      ? tree.getNodes(node => node.key === 2, false, tree.root, 'RECURSIVE')
+      : tree.getNodes(node => node.value === 'B', false, tree.root, 'RECURSIVE');
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(2);
 
-    const nodesItr = tree.getNodes(node => node.value === 'B', false, tree.root, 'ITERATIVE');
+    const nodesItr = tree.isMapMode
+      ? tree.getNodes(node => node.key === 2, false, tree.root, 'ITERATIVE')
+      : tree.getNodes(node => node.value === 'B', false, tree.root, 'ITERATIVE');
 
     expect(nodesItr.length).toBe(1);
     expect(nodesItr[0].key).toBe(2);
@@ -1186,6 +1220,98 @@ describe('BinaryTree', () => {
   });
 });
 
+describe('BinaryTree map mode', () => {
+  let tree: BinaryTree<number, string>;
+
+  beforeEach(() => {
+    tree = new BinaryTree<number, string>([], {
+      iterationType: 'RECURSIVE',
+      isMapMode: true
+    });
+  });
+
+  afterEach(() => {
+    tree.clear();
+  });
+
+  it('should add and find nodes', () => {
+    tree.add([1, 1]);
+    tree.add(undefined);
+    tree.add([2, 2]);
+    tree.add([3, 3]);
+
+    expect(tree.has(1)).toBe(true);
+    expect(tree.has(2)).toBe(true);
+    expect(tree.has(3)).toBe(true);
+    expect(tree.has(4)).toBe(false);
+    const node4 = tree.getNode(4);
+    expect(tree.has(node4)).toBe(false);
+    expect(tree.has(node => node === node4)).toBe(false);
+    if (tree.isMapMode) expect(tree.has(node => node.key?.toString() === '3')).toBe(true);
+    else expect(tree.has(node => node.value?.toString() === '3')).toBe(true);
+  });
+
+  it('should isSubtreeBST', () => {
+    tree.addMany([
+      new BinaryTreeNode(4),
+      new BinaryTreeNode(2),
+      new BinaryTreeNode(6),
+      new BinaryTreeNode(1),
+      new BinaryTreeNode(3),
+      new BinaryTreeNode(5),
+      new BinaryTreeNode(7),
+      new BinaryTreeNode(4)
+    ]);
+
+    expect(tree.isBST(tree.getNode(4), 'RECURSIVE')).toBe(true);
+    expect(tree.isBST(tree.getNode(4), 'ITERATIVE')).toBe(true);
+  });
+
+  it('should get nodes by key', () => {
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
+
+    const nodeA = tree.getNode(5);
+    const nodeB = tree.getNode(3);
+
+    expect(nodeA?.key).toBe(5);
+    expect(tree.get(nodeA)).toBe('A');
+    expect(nodeB?.key).toBe(3);
+    expect(tree.get(nodeB)).toBe('B');
+  });
+
+  it('should get nodes by a custom callback', () => {
+    tree.add([5, 'E']);
+    tree.add([4, 'D']);
+    tree.add([3, 'C']);
+    tree.add([7, 'G']);
+    tree.add([null, 'null']);
+    tree.add([1, 'A']);
+    tree.add([6, 'F']);
+    tree.add([null, 'null']);
+    tree.add([2, 'B']);
+    tree.add([null, 'null']);
+
+    const nodes = tree.getNodes(node => node.key === 2);
+
+    expect(nodes.length).toBe(1);
+    expect(nodes[0].key).toBe(2);
+
+    const nodesRec = tree.getNodes(node => node.key === 2, false, tree.root, 'RECURSIVE');
+
+    expect(nodesRec.length).toBe(1);
+    expect(nodesRec[0].key).toBe(2);
+
+    const nodesItr = tree.getNodes(node => node.key === 2, false, tree.root, 'ITERATIVE');
+
+    expect(nodesItr.length).toBe(1);
+    expect(nodesItr[0].key).toBe(2);
+
+    expect(nodesItr).toEqual(nodesRec);
+  });
+});
+
 describe('BinaryTree iterative methods test', () => {
   let binaryTree: BinaryTree<number, string>;
   beforeEach(() => {
@@ -1253,7 +1379,8 @@ describe('BinaryTree iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = binaryTree.clone();
     expect(cloned.root?.left?.key).toBe(2);
-    expect(cloned.root?.right?.value).toBe('c');
+    if (cloned.isMapMode) expect(cloned.get(cloned.root?.right)).toBe('c');
+    else expect(cloned.root?.right?.value).toBe('c');
   });
 
   it('should keys', () => {
@@ -1295,3 +1422,19 @@ describe('BinaryTree iterative methods test', () => {
     ]);
   });
 });
+
+describe('BinaryTree map mode iterative methods test', () => {
+  let binaryTree: BinaryTree<number, string>;
+  beforeEach(() => {
+    binaryTree = new BinaryTree<number, string>([], { isMapMode: true });
+    binaryTree.add([1, 'a']);
+    binaryTree.add(2, 'b');
+    binaryTree.add([3, 'c']);
+  });
+
+  it('should clone work well', () => {
+    const cloned = binaryTree.clone();
+    expect(cloned.root?.left?.key).toBe(2);
+    expect(cloned.get(cloned.root?.right)).toBe('c');
+  });
+});