data-structure-typed 1.52.9 → 1.53.1

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

@@ -1,5 +1,5 @@
 import { BinaryTreeNode, BST, BSTNode } from '../../../../src';
-import { isDebugTest, SYSTEM_MAX_CALL_STACK, isTestStackOverflow } from '../../../config';
+import { isDebugTest, isTestStackOverflow, SYSTEM_MAX_CALL_STACK } from '../../../config';
 
 const isDebug = isDebugTest;
 
@@ -74,7 +74,7 @@ describe('BST operations test', () => {
     const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.getNode(node => node.value === 9);
+    const nodeVal9 = bst.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
@@ -86,7 +86,7 @@ describe('BST operations test', () => {
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
-    const nodes = bst.getNodes(node => node.value === 15);
+    const nodes = bst.getNodes(node => node.key === 15);
     expect(nodes.map(node => node.key)).toEqual([15]);
 
     let subTreeSum = 0;
@@ -291,7 +291,7 @@ describe('BST operations test', () => {
     expect(leftMost).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({
+    expect(objBST.get(node15)).toEqual({
       name: 'Alice',
       age: 15
     });
@@ -450,22 +450,44 @@ describe('BST operations test', () => {
     expect(bfsNodes[2].key).toBe(16);
   });
 
-  it('should keyValueOrEntryOrRawElementToNode', () => {
+  it('should keyValueNodeEntryRawToNodeAndValue', () => {
     const bst = new BST<number>();
-    const node0 = bst.keyValueOrEntryOrRawElementToNode(0);
-    expect(node0).toEqual({
-      _left: undefined,
-      _right: undefined,
-      key: 0,
-      parent: undefined,
-      value: undefined
-    });
+    const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
+    expect(node0).toEqual([
+      {
+        _left: undefined,
+        _right: undefined,
+        key: 0,
+        parent: undefined,
+        value: undefined
+      },
+      undefined
+    ]);
 
-    const nodeUndefined = bst.keyValueOrEntryOrRawElementToNode(undefined);
-    expect(nodeUndefined).toBe(undefined);
+    const nodeUndefined = bst.keyValueNodeEntryRawToNodeAndValue(undefined);
+    expect(nodeUndefined).toEqual([undefined, undefined]);
 
-    const nodeNull = bst.keyValueOrEntryOrRawElementToNode(null);
-    expect(nodeNull).toBe(undefined);
+    const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
+    expect(nodeNull).toEqual([undefined, undefined]);
+  });
+
+  it('should replace value', () => {
+    const tree = new BST<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
+    expect(tree.get(1)).toBe('1');
+    expect(tree.getNode(1)?.value).toBe('1');
+    tree.add(1, 'a');
+    expect(tree.get(1)).toBe('a');
+    tree.add([1, 'b']);
+    expect(tree.getNode(1)?.value).toBe('b');
+    expect(tree.get(1)).toBe('b');
+    const treeMap = new BST<number>([4, 5, [1, '1'], 2, 3]);
+    expect(treeMap.get(1)).toBe('1');
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    treeMap.add(1, 'a');
+    expect(treeMap.get(1)).toBe('a');
+    treeMap.add([1, 'b']);
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.get(1)).toBe('b');
   });
 });
 
@@ -496,7 +518,7 @@ describe('BST operations test recursively', () => {
     expect(nodeId10?.key).toBe(10);
 
     const nodeVal9 = bst.getNode(node => node.value === 9);
-    expect(nodeVal9?.key).toBe(undefined);
+    expect(bst.get(nodeVal9?.key)).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost).toBe(1);
@@ -705,7 +727,7 @@ describe('BST operations test recursively', () => {
     expect(leftMost).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({
+    expect(objBST.get(node15)).toEqual({
       key: 15,
       keyA: 15
     });
@@ -1132,7 +1154,7 @@ describe('BST iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = bst.clone();
     expect(cloned.root?.left).toBe(undefined);
-    expect(cloned.root?.right?.value).toBe('b');
+    expect(cloned.root?.right?.value).toBe(undefined);
   });
 
   it('should keys', () => {
@@ -1207,6 +1229,303 @@ describe('BST iterative methods test', () => {
     );
 
     expect(balanced.leaves()).toEqual([1, 6, 4, 9]);
-    expect(balanced.leaves(node => node?.value)).toEqual(['a', 'f', 'd', 'i']);
+    expect(balanced.leaves(node => balanced.get(node))).toEqual(['a', 'f', 'd', 'i']);
+  });
+});
+
+describe('BST operations not map mode test', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+    const bst = new BST<number, number>([], { isMapMode: false });
+    expect(bst).toBeInstanceOf(BST);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
+    const idsAndValues: [number, number][] = [
+      [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]
+    ];
+    bst.addMany(idsAndValues, undefined, false);
+    expect(bst.root).toBeInstanceOf(BSTNode);
+
+    if (bst.root) expect(bst.root.key).toBe(11);
+
+    expect(bst.size).toBe(16);
+
+    expect(bst.has(6)).toBe(true);
+
+    const node6 = bst.getNode(6);
+    expect(node6 && bst.getHeight(6)).toBe(2);
+    expect(node6 && bst.getDepth(6)).toBe(3);
+
+    const nodeId10 = bst.getNode(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = bst.getNode(node => node.key === 9);
+    expect(nodeVal9?.key).toBe(9);
+
+    const leftMost = bst.getLeftMost();
+    expect(leftMost).toBe(1);
+
+    expect(bst.isBST()).toBe(true);
+
+    const node15 = bst.getNode(15);
+    const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
+    expect(minNodeBySpecificNode?.key).toBe(12);
+
+    const nodes = bst.getNodes(node => node.key === 15);
+    expect(nodes.map(node => node.key)).toEqual([15]);
+  });
+
+  it('should perform various operations on a Binary Search Tree with object values', () => {
+    const objBST = new BST<number, { name: string; age: number }>([], { isMapMode: false });
+    expect(objBST).toBeInstanceOf(BST);
+    objBST.add([11, { name: '11', age: 11 }]);
+    objBST.add([3, { name: '3', age: 3 }]);
+
+    objBST.addMany(
+      [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5],
+      [
+        { name: 'Alice', age: 15 },
+        { name: 'Bob', age: 1 },
+        { name: 'Charlie', age: 8 },
+        { name: 'David', age: 13 },
+        { name: 'Emma', age: 16 },
+        { name: 'Frank', age: 2 },
+        { name: 'Grace', age: 6 },
+        { name: 'Hannah', age: 9 },
+        { name: 'Isaac', age: 12 },
+        { name: 'Jack', age: 14 },
+        { name: 'Katie', age: 4 },
+        { name: 'Liam', age: 7 },
+        { name: 'Mia', age: 10 },
+        { name: 'Noah', age: 5 }
+      ],
+      false
+    );
+
+    expect(objBST.root).toBeInstanceOf(BSTNode);
+
+    if (objBST.root) expect(objBST.root.key).toBe(11);
+
+    expect(objBST.has(6)).toBe(true);
+
+    const node6 = objBST.getNode(6);
+    expect(node6 && objBST.getHeight(node6)).toBe(2);
+    expect(node6 && objBST.getDepth(node6)).toBe(3);
+
+    const nodeId10 = objBST.getNode(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = objBST.getNode(9);
+    expect(nodeVal9?.key).toBe(9);
+
+    const leftMost = objBST.getLeftMost();
+    expect(leftMost).toBe(1);
+
+    const node15 = objBST.getNode(15);
+    expect(objBST.get(node15)).toEqual({
+      name: 'Alice',
+      age: 15
+    });
+  });
+
+  it('should keyValueNodeEntryRawToNodeAndValue', () => {
+    const bst = new BST<number>([], { isMapMode: false });
+    const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
+    expect(node0).toEqual([
+      {
+        _left: undefined,
+        _right: undefined,
+        key: 0,
+        parent: undefined,
+        value: undefined
+      },
+      undefined
+    ]);
+
+    const nodeUndefined = bst.keyValueNodeEntryRawToNodeAndValue(undefined);
+    expect(nodeUndefined).toEqual([undefined, undefined]);
+
+    const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
+    expect(nodeNull).toEqual([undefined, undefined]);
+  });
+});
+
+describe('BST operations not map mode test recursively', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+    const bst = new BST<number>([], {
+      iterationType: 'RECURSIVE',
+      isMapMode: false
+    });
+    expect(bst).toBeInstanceOf(BST);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
+    const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    bst.addMany(idsAndValues, undefined, false);
+    expect(bst.root).toBeInstanceOf(BSTNode);
+
+    if (bst.root) expect(bst.root.key).toBe(11);
+
+    expect(bst.size).toBe(16);
+
+    expect(bst.has(6)).toBe(true);
+
+    const node6 = bst.getNode(6);
+    expect(node6 && bst.getHeight(6)).toBe(2);
+    expect(node6 && bst.getDepth(6)).toBe(3);
+
+    const nodeId10 = bst.getNode(10);
+    expect(bst.get(10)).toBe(undefined);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = bst.getNode(node => node.key === 9);
+    expect(bst.get(nodeVal9?.key)).toBe(undefined);
+  });
+
+  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 entries: [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(entries, undefined, false);
+
+    expect(objBST.root).toBeInstanceOf(BSTNode);
+
+    if (objBST.root) expect(objBST.root.key).toBe(11);
+
+    expect(objBST.has(6)).toBe(true);
+
+    const node6 = objBST.getNode(6);
+    expect(objBST.get(6)).toEqual({
+      key: 6,
+      keyA: 6
+    });
+    expect(node6 && objBST.getHeight(node6)).toBe(2);
+    expect(node6 && objBST.getDepth(node6)).toBe(3);
+
+    const nodeId10 = objBST.getNode(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = objBST.getNode(9);
+    expect(nodeVal9?.key).toBe(9);
+
+    const leftMost = objBST.getLeftMost();
+    expect(leftMost).toBe(1);
+
+    const node15 = objBST.getNode(15);
+    expect(objBST.get(node15)).toEqual({
+      key: 15,
+      keyA: 15
+    });
+  });
+});
+
+describe('BST iterative methods not map mode test', () => {
+  let bst: BST<number, string>;
+  beforeEach(() => {
+    bst = new BST();
+    bst.addMany(
+      [
+        [1, 'a'],
+        [2, 'b'],
+        [3, 'c']
+      ],
+      [],
+      false
+    );
+  });
+
+  it('should clone work well', () => {
+    const cloned = bst.clone();
+    expect(cloned.root?.left).toBe(undefined);
+    expect(cloned.get(cloned.root?.right)).toBe('b');
+  });
+
+  it('should collapsed, unbalanced, balanced bst leaves', () => {
+    const collapsedToLinkedList = new BST();
+    collapsedToLinkedList.addMany(
+      [
+        [1, 'a'],
+        [2, 'b'],
+        [3, 'c'],
+        [4, 'd'],
+        [5, 'e'],
+        [6, 'f'],
+        [7, 'g'],
+        [8, 'h'],
+        [9, 'i']
+      ],
+      [],
+      false
+    );
+
+    expect(collapsedToLinkedList.leaves()).toEqual([9]);
+
+    const unbalanced = new BST();
+    unbalanced.addMany(
+      [
+        [2, 'b'],
+        [1, 'a'],
+        [3, 'c'],
+        [4, 'd'],
+        [5, 'e'],
+        [6, 'f'],
+        [7, 'g'],
+        [8, 'h'],
+        [9, 'i']
+      ],
+      [],
+      false
+    );
+
+    expect(unbalanced.leaves()).toEqual([1, 9]);
+
+    const balanced = new BST();
+    balanced.addMany(
+      [
+        [2, 'b'],
+        [1, 'a'],
+        [3, 'c'],
+        [4, 'd'],
+        [5, 'e'],
+        [6, 'f'],
+        [7, 'g'],
+        [8, 'h'],
+        [9, 'i']
+      ],
+      [],
+      true
+    );
+
+    expect(balanced.leaves()).toEqual([1, 6, 4, 9]);
+    expect(balanced.leaves(node => balanced.get(node?.key))).toEqual(['a', 'f', 'd', 'i']);
   });
 });

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

@@ -182,6 +182,25 @@ describe('RedBlackTree 1', () => {
     expect(rbTree.size).toBe(4);
     expect(cloned.size).toBe(3);
   });
+
+  it('should replace value', () => {
+    const tree = new RedBlackTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
+    expect(tree.get(1)).toBe('1');
+    expect(tree.getNode(1)?.value).toBe('1');
+    tree.add(1, 'a');
+    expect(tree.get(1)).toBe('a');
+    tree.add([1, 'b']);
+    expect(tree.getNode(1)?.value).toBe('b');
+    expect(tree.get(1)).toBe('b');
+    const treeMap = new RedBlackTree<number>([4, 5, [1, '1'], 2, 3]);
+    expect(treeMap.get(1)).toBe('1');
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    treeMap.add(1, 'a');
+    expect(treeMap.get(1)).toBe('a');
+    treeMap.add([1, 'b']);
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.get(1)).toBe('b');
+  });
 });
 
 describe('RedBlackTree 2', () => {

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

@@ -133,7 +133,7 @@ describe('TreeMultiMap operations test1', () => {
     const nodeId10 = tmm.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = tmm.getNode(node => node.value === 9);
+    const nodeVal9 = tmm.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = tmm.getNodes(node => node.count === 1);
@@ -391,7 +391,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     const nodeId10 = tmm.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = tmm.getNode(node => node.value === 9);
+    const nodeVal9 = tmm.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = tmm.getNodes(node => node.count === 1);
@@ -817,7 +817,8 @@ describe('TreeMultiMap iterative methods test', () => {
     expect(treeMM.getComputedCount()).toBe(21);
     const cloned = treeMM.clone();
     expect(cloned.root?.left?.key).toBe(1);
-    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(undefined);
   });
 
   it('should keys', () => {
@@ -835,3 +836,140 @@ describe('TreeMultiMap iterative methods test', () => {
     expect(leaves).toEqual([1, 3]);
   });
 });
+
+describe('TreeMultiMap count not map mode', () => {
+  let tmm: TreeMultiMap<number>;
+  beforeEach(() => {
+    tmm = new TreeMultiMap<number>([], { isMapMode: false });
+  });
+
+  it('Should added node count ', () => {
+    tmm.addMany([
+      [1, 1],
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5]
+    ]);
+    const newNode = new TreeMultiMapNode(3, undefined, 10);
+    tmm.add(newNode, 33, 20);
+    // TODO expect(tmm.count).toBe(25);
+    expect(tmm.count).toBe(15);
+    expect(tmm.getComputedCount()).toBe(15);
+    expect(tmm.getNode(3)?.count).toBe(11);
+  });
+});
+
+describe('TreeMultiMap operations test1 not map mode', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
+    const tmm = new TreeMultiMap<number, number>([], { isMapMode: false });
+
+    expect(tmm instanceof TreeMultiMap);
+
+    tmm.add([11, 11]);
+    tmm.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]
+    ];
+    tmm.addMany(idAndValues);
+    expect(tmm.root instanceof TreeMultiMapNode);
+
+    if (tmm.root) expect(tmm.root.key == 11);
+
+    expect(tmm.size).toBe(16);
+    expect(tmm.count).toBe(18);
+    expect(tmm.getComputedCount()).toBe(18);
+
+    expect(tmm.has(6));
+    if (isDebug) tmm.print();
+    expect(tmm.getHeight(6)).toBe(1);
+    expect(tmm.getDepth(6)).toBe(3);
+    const nodeId10 = tmm.getNode(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = tmm.getNode(node => node.key === 9);
+    expect(nodeVal9?.key).toBe(9);
+  });
+});
+
+describe('TreeMultiMap operations test recursively1 not map mode', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
+    const tmm = new TreeMultiMap<number>([], {
+      iterationType: 'RECURSIVE',
+      isMapMode: false
+    });
+
+    expect(tmm instanceof TreeMultiMap);
+    tmm.add([11, 11]);
+    tmm.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]
+    ];
+    tmm.addMany(idAndValues);
+    expect(tmm.root).toBeInstanceOf(TreeMultiMapNode);
+
+    if (tmm.root) expect(tmm.root.key).toBe(5);
+
+    expect(tmm.size).toBe(16);
+    expect(tmm.count).toBe(18);
+    expect(tmm.getComputedCount()).toBe(18);
+
+    expect(tmm.has(6));
+
+    expect(tmm.getHeight(6)).toBe(1);
+    expect(tmm.getDepth(6)).toBe(3);
+    const nodeId10 = tmm.getNode(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = tmm.getNode(node => node.key === 9);
+    expect(nodeVal9?.key).toBe(9);
+  });
+});
+
+describe('TreeMultiMap iterative methods test not map mode', () => {
+  let treeMM: TreeMultiMap<number, string>;
+  beforeEach(() => {
+    treeMM = new TreeMultiMap<number, string>([], { isMapMode: false });
+    treeMM.add(1, 'a', 10);
+    treeMM.add([2, 'b'], undefined, 10);
+    treeMM.add([3, 'c'], undefined, 1);
+  });
+
+  it('should clone work well', () => {
+    expect(treeMM.count).toBe(21);
+    expect(treeMM.getComputedCount()).toBe(21);
+    const cloned = treeMM.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.get(cloned.root?.right)).toBe(undefined);
+  });
+});

package/test/utils/array.ts

@@ -1,19 +1,22 @@
 import { getRandomInt } from './number';
 
-export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, isDistinct = true) {
-  if (isDistinct) {
-    const set = new Set<number>();
-    const ans: number[] = [];
-    while (ans.length < length) {
-      const num = getRandomInt(min, max);
-      if (!set.has(num)) {
-        ans.push(num);
-        set.add(num);
-      }
+export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, unique = true) {
+  if (unique) {
+    if (max - min + 1 < length) {
+      throw new Error("Range too small for unique values with the specified length");
     }
-    return ans;
+
+    const allNumbers = Array.from({ length: max - min + 1 }, (_, i) => i + min);
+
+    for (let i = allNumbers.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
+    }
+
+    return allNumbers.slice(0, length);
+  } else {
+    return Array.from({ length }, () => Math.floor(Math.random() * (max - min + 1)) + min);
   }
-  return new Array<number>(length).fill(0).map(() => getRandomInt(min, max));
 }
 
 const words = [