data-structure-typed 1.50.3 → 1.50.4

package/src/types/data-structures/binary-tree/index.ts

@@ -2,5 +2,6 @@ export * from './binary-tree';
 export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';
-export * from './tree-multimap';
+export * from './avl-tree-multi-map';
 export * from './rb-tree';
+export * from './tree-multi-map';

package/src/types/data-structures/binary-tree/tree-multi-map.ts

@@ -0,0 +1,8 @@
+import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
+import type { RBTreeOptions } from './rb-tree';
+
+export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultiMapNested<K, V, N extends TreeMultiMapNode<K, V, N>> = TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultiMapOptions<K> = RBTreeOptions<K> & {}

package/test/integration/index.html

@@ -232,7 +232,7 @@
       RedBlackTree,
       SinglyLinkedList,
       Stack,
-      TreeMultimap,
+      TreeMultiMap,
       Trie
     } = dataStructureTyped;
     const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
@@ -302,7 +302,7 @@
     //              /   \
     //              7   9
 
-    const treeMulti = new TreeMultimap(entries);
+    const treeMulti = new TreeMultiMap(entries);
     treeMulti.print();
     //     ___4___
     //    /       \

package/test/unit/data-structures/binary-tree/{tree-multimap.test.ts → avl-tree-multi-map.test.ts}

@@ -1,20 +1,20 @@
 import {
+  AVLTreeMultiMap,
+  AVLTreeMultiMapNode,
   AVLTreeNode,
   BinaryTreeNode,
   BSTNode,
   CP,
-  IterationType,
-  TreeMultimap,
-  TreeMultimapNode
+  IterationType
 } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
-describe('TreeMultimap count', () => {
-  let tm: TreeMultimap<number>;
+describe('AVLTreeMultiMap count', () => {
+  let tm: AVLTreeMultiMap<number>;
   beforeEach(() => {
-    tm = new TreeMultimap<number>();
+    tm = new AVLTreeMultiMap<number>();
   });
   it('Should added isolated node count ', () => {
     tm.addMany([
@@ -24,7 +24,7 @@ describe('TreeMultimap count', () => {
       [4, 4],
       [5, 5]
     ]);
-    const newNode = new TreeMultimapNode(3, 33, 10);
+    const newNode = new AVLTreeMultiMapNode(3, 33, 10);
     tm.add(newNode);
     expect(tm.count).toBe(15);
   });
@@ -40,11 +40,11 @@ describe('TreeMultimap count', () => {
   });
 });
 
-describe('TreeMultimap operations test1', () => {
+describe('AVLTreeMultiMap operations test1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new TreeMultimap();
+    const treeMultimap = new AVLTreeMultiMap();
 
-    expect(treeMultimap instanceof TreeMultimap);
+    expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
     treeMultimap.add([3, 3]);
     const idAndValues: [number, number][] = [
@@ -66,7 +66,7 @@ describe('TreeMultimap operations test1', () => {
       [5, 5]
     ];
     treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root instanceof TreeMultimapNode);
+    expect(treeMultimap.root instanceof AVLTreeMultiMapNode);
 
     if (treeMultimap.root) expect(treeMultimap.root.key == 11);
 
@@ -99,17 +99,17 @@ describe('TreeMultimap operations test1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(21);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
 
-    expect(node15 instanceof TreeMultimapNode);
-    if (node15 instanceof TreeMultimapNode) {
+    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 TreeMultimapNode);
-    if (node11 instanceof TreeMultimapNode) {
+    expect(node11 instanceof AVLTreeMultiMapNode);
+    if (node11 instanceof AVLTreeMultiMapNode) {
       const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
       expect(allGreaterNodesAdded);
     }
@@ -257,14 +257,14 @@ describe('TreeMultimap operations test1', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(4);
+    expect(treeMultimap.count).toBe(8);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<number, { key: number; keyA: number }>();
-    expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
-    objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
+    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 }],
@@ -282,23 +282,23 @@ describe('TreeMultimap operations test1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeMultimap.addMany(values);
+    objAVLTreeMultiMap.addMany(values);
 
-    expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
+    expect(objAVLTreeMultiMap.root).toBeInstanceOf(AVLTreeMultiMapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
+    if (objAVLTreeMultiMap.root) expect(objAVLTreeMultiMap.root.key).toBe(6);
 
-    expect(objTreeMultimap.count).toBe(16);
+    expect(objAVLTreeMultiMap.count).toBe(16);
 
-    expect(objTreeMultimap.has(6)).toBe(true);
+    expect(objAVLTreeMultiMap.has(6)).toBe(true);
   });
 });
 
-describe('TreeMultimap operations test recursively1', () => {
+describe('AVLTreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new TreeMultimap<number>([], { iterationType: IterationType.RECURSIVE });
+    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
 
-    expect(treeMultimap instanceof TreeMultimap);
+    expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
     treeMultimap.add([3, 3]);
     const idAndValues: [number, number][] = [
@@ -320,7 +320,7 @@ describe('TreeMultimap operations test recursively1', () => {
       [5, 5]
     ];
     treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root).toBeInstanceOf(TreeMultimapNode);
+    expect(treeMultimap.root).toBeInstanceOf(AVLTreeMultiMapNode);
 
     if (treeMultimap.root) expect(treeMultimap.root.key).toBe(6);
 
@@ -353,17 +353,17 @@ describe('TreeMultimap operations test recursively1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(21);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
 
-    expect(node15 instanceof TreeMultimapNode);
-    if (node15 instanceof TreeMultimapNode) {
+    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 TreeMultimapNode);
-    if (node11 instanceof TreeMultimapNode) {
+    expect(node11 instanceof AVLTreeMultiMapNode);
+    if (node11 instanceof AVLTreeMultiMapNode) {
       const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
       expect(allGreaterNodesAdded);
     }
@@ -511,14 +511,14 @@ describe('TreeMultimap operations test recursively1', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(4);
+    expect(treeMultimap.count).toBe(8);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<number, { key: number; keyA: number }>();
-    expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
-    objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
+    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 }],
@@ -536,27 +536,27 @@ describe('TreeMultimap operations test recursively1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeMultimap.addMany(values);
+    objAVLTreeMultiMap.addMany(values);
 
-    expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
+    expect(objAVLTreeMultiMap.root).toBeInstanceOf(AVLTreeMultiMapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
+    if (objAVLTreeMultiMap.root) expect(objAVLTreeMultiMap.root.key).toBe(6);
 
-    expect(objTreeMultimap.count).toBe(16);
+    expect(objAVLTreeMultiMap.count).toBe(16);
 
-    expect(objTreeMultimap.has(6)).toBe(true);
+    expect(objAVLTreeMultiMap.has(6)).toBe(true);
   });
 });
 
-describe('TreeMultimap Performance test', function () {
-  const treeMS = new TreeMultimap<number, number>();
+describe('AVLTreeMultiMap Performance test', function () {
+  const treeMS = new AVLTreeMultiMap<number, number>();
   const inputSize = 100000; // Adjust input sizes as needed
 
   beforeEach(() => {
     treeMS.clear();
   });
 
-  it(`Observe the time consumption of TreeMultimap.dfs be good`, function () {
+  it(`Observe the time consumption of AVLTreeMultiMap.dfs be good`, function () {
     const startDFS = performance.now();
     const dfs = treeMS.dfs(node => node);
     isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
@@ -574,7 +574,7 @@ describe('TreeMultimap Performance test', function () {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(treeMultimap: TreeMultimap<string, number>) {
+    function checkTreeStructure(treeMultimap: AVLTreeMultiMap<string, number>) {
       expect(treeMultimap.size).toBe(4);
       expect(treeMultimap.root?.key).toBe('2');
       expect(treeMultimap.root?.left?.key).toBe('1');
@@ -585,7 +585,7 @@ describe('TreeMultimap Performance test', function () {
       expect(treeMultimap.root?.right?.right?.key).toBe('5');
     }
 
-    const treeMultimap = new TreeMultimap<string, number>();
+    const treeMultimap = new AVLTreeMultiMap<string, number>();
     treeMultimap.addMany([
       ['2', 2],
       ['4', 4],
@@ -611,10 +611,10 @@ describe('TreeMultimap Performance test', function () {
   });
 });
 
-describe('TreeMultimap iterative methods test', () => {
-  let treeMM: TreeMultimap<number, string>;
+describe('AVLTreeMultiMap iterative methods test', () => {
+  let treeMM: AVLTreeMultiMap<number, string>;
   beforeEach(() => {
-    treeMM = new TreeMultimap<number, string>();
+    treeMM = new AVLTreeMultiMap<number, string>();
     treeMM.add(1, 'a', 10);
     treeMM.add([2, 'b'], undefined, 10);
     treeMM.add([3, 'c'], undefined, 1);

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

@@ -1,4 +1,4 @@
-import { AVLTree, BST, BSTVariant, IterationType, RedBlackTree, TreeMultimap } from '../../../../src';
+import { AVLTree, BST, BSTVariant, IterationType, RedBlackTree, TreeMultiMap } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
@@ -146,10 +146,9 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedAVL.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
   });
 
-  it('Should clone a TreeMultimap works fine', () => {
-    const tmm = new TreeMultimap<number>([3, 6, 7, 1, 9], {
+  it('Should clone a TreeMultiMap works fine', () => {
+    const tmm = new TreeMultiMap<number>([3, 6, 7, 1, 9], {
       iterationType: IterationType.RECURSIVE,
-      variant: BSTVariant.INVERSE,
       extractor: key => key
     });
     expect(tmm.size).toBe(5);
@@ -159,40 +158,40 @@ describe('Overall BinaryTree Test', () => {
     tmm.add(5);
     tmm.add(4);
     expect(tmm.count).toBe(10);
-    expect(tmm.root?.key).toBe(3);
-    expect(tmm.root?.left?.key).toBe(7);
-    expect(tmm.root?.left?.left?.key).toBe(9);
-    expect(tmm.root?.right?.key).toBe(1);
-    expect(tmm.root?.right?.left?.key).toBe(2);
-    expect(tmm.getNodeByKey(7)?.left?.key).toBe(9);
-    expect(tmm.getHeight()).toBe(3);
+    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.left?.key).toBe(1);
+    expect(tmm.root?.left?.left?.key).toBe(NaN);
+    expect(tmm.root?.right?.key).toBe(7);
+    expect(tmm.root?.right?.left?.key).toBe(NaN);
+    expect(tmm.getNodeByKey(7)?.left?.key).toBe(NaN);
+    expect(tmm.getHeight()).toBe(5);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(true);
     expect(tmm.delete(7)[0].deleted?.key).toBe(7);
     expect(tmm.has(7)).toBe(false);
     expect(tmm.size).toBe(7);
     expect(tmm.count).toBe(9);
-    expect(tmm.root?.key).toBe(3);
-    expect(tmm.root?.left?.key).toBe(5);
-    expect(tmm.root?.right?.key).toBe(1);
-    expect(tmm.root?.right?.left?.key).toBe(2);
-    expect(tmm.getNodeByKey(6)?.left?.key).toBe(undefined);
-    expect(tmm.getHeight()).toBe(3);
+    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.left?.key).toBe(1);
+    expect(tmm.root?.right?.key).toBe(9);
+    expect(tmm.root?.right?.left?.key).toBe(NaN);
+    expect(tmm.getNodeByKey(6)?.left?.key).toBe(1);
+    expect(tmm.getHeight()).toBe(5);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(false);
-    expect(tmm.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
+    expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
     const clonedTMM = tmm.clone();
     expect(clonedTMM.size).toBe(7);
     expect(clonedTMM.count).toBe(9);
-    expect(clonedTMM.root?.key).toBe(3);
-    expect(clonedTMM.root?.left?.key).toBe(5);
-    expect(clonedTMM.root?.right?.key).toBe(1);
-    expect(clonedTMM.root?.right?.left?.key).toBe(2);
-    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(undefined);
-    expect(clonedTMM.getHeight()).toBe(3);
+    expect(clonedTMM.root?.key).toBe(6);
+    expect(clonedTMM.root?.left?.key).toBe(1);
+    expect(clonedTMM.root?.right?.key).toBe(9);
+    expect(clonedTMM.root?.right?.left?.key).toBe(NaN);
+    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(1);
+    expect(clonedTMM.getHeight()).toBe(5);
     expect(clonedTMM.has(9)).toBe(true);
     expect(clonedTMM.has(7)).toBe(false);
-    expect(clonedTMM.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
+    expect(clonedTMM.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
   });
 
   it('Should clone a RedBlackTree works fine', () => {