data-structure-typed 1.47.6 → 1.47.7

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

@@ -3,15 +3,52 @@ import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
-describe('TreeMultimap operations test', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+describe('TreeMultimap count', () => {
+  let tm: TreeMultimap<number>;
+  beforeEach(() => {
+    tm = new TreeMultimap<number>();
+
+  })
+  it('Should added isolated node count ', () => {
+    tm.addMany([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]);
+    const newNode = new TreeMultimapNode(3, 33, 10);
+    tm.add(newNode);
+    expect(tm.count).toBe(15)
+  })
+
+  it('Should count', () => {
+    tm.addMany([[1, 1], [2, 2], [3, 3]]);
+    tm.lesserOrGreaterTraverse(node => node.count += 2, CP.gt, 1);
+    expect(tm.count).toBe(7)
+  })
+})
+
+describe('TreeMultimap operations test1', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
     const treeMultimap = new TreeMultimap();
 
     expect(treeMultimap instanceof TreeMultimap);
-    treeMultimap.add(11, 11);
-    treeMultimap.add(3, 3);
-    const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    treeMultimap.addMany(idAndValues, idAndValues);
+    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 TreeMultimapNode);
 
     if (treeMultimap.root) expect(treeMultimap.root.key == 11);
@@ -21,8 +58,8 @@ describe('TreeMultimap operations test', () => {
 
     expect(treeMultimap.has(6));
 
-    expect(treeMultimap.getHeight(6)).toBe(3);
-    expect(treeMultimap.getDepth(6)).toBe(1);
+    expect(treeMultimap.getHeight(6)).toBe(4);
+    expect(treeMultimap.getDepth(6)).toBe(0);
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
@@ -39,14 +76,14 @@ describe('TreeMultimap operations test', () => {
 
     const node15 = treeMultimap.getNode(15);
     const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.key).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
     node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
-    expect(subTreeSum).toBe(70);
+    expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(45);
+    expect(lesserSum).toBe(21);
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
@@ -203,39 +240,38 @@ describe('TreeMultimap operations test', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(9);
+    expect(treeMultimap.count).toBe(4);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, { key: 11, keyA: 11 });
-    objTreeMultimap.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
+    objTreeMultimap.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 }]
     ];
 
     objTreeMultimap.addMany(
-      values.map(item => item.key),
       values
     );
 
     expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11);
+    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
 
     expect(objTreeMultimap.count).toBe(16);
 
@@ -243,26 +279,43 @@ describe('TreeMultimap operations test', () => {
   });
 });
 
-describe('TreeMultimap operations test recursively', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const treeMultimap = new TreeMultimap([], { iterationType: IterationType.RECURSIVE });
+describe('TreeMultimap operations test recursively1', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
+    const treeMultimap = new TreeMultimap<number>([], { iterationType: IterationType.RECURSIVE });
 
     expect(treeMultimap instanceof TreeMultimap);
-    treeMultimap.add(11, 11);
-    treeMultimap.add(3, 3);
-    const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    treeMultimap.addMany(idAndValues, idAndValues);
-    expect(treeMultimap.root instanceof TreeMultimapNode);
+    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(TreeMultimapNode);
 
-    if (treeMultimap.root) expect(treeMultimap.root.key == 11);
+    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(3);
-    expect(treeMultimap.getDepth(6)).toBe(1);
+    expect(treeMultimap.getHeight(6)).toBe(4);
+    expect(treeMultimap.getDepth(6)).toBe(0);
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
@@ -279,14 +332,14 @@ describe('TreeMultimap operations test recursively', () => {
 
     const node15 = treeMultimap.getNode(15);
     const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.key).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
     node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
-    expect(subTreeSum).toBe(70);
+    expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(45);
+    expect(lesserSum).toBe(21);
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
@@ -303,7 +356,7 @@ describe('TreeMultimap operations test recursively', () => {
     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);
+    expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
 
     treeMultimap.perfectlyBalance();
 
@@ -443,39 +496,38 @@ describe('TreeMultimap operations test recursively', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(9);
+    expect(treeMultimap.count).toBe(4);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, { key: 11, keyA: 11 });
-    objTreeMultimap.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
+    objTreeMultimap.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 }]
     ];
 
     objTreeMultimap.addMany(
-      values.map(item => item.key),
       values
     );
 
     expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11);
+    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
 
     expect(objTreeMultimap.count).toBe(16);
 

package/test/unit/unrestricted-interconversion.test.ts

@@ -4,6 +4,8 @@ import {
   BST,
   Deque,
   DoublyLinkedList,
+  HashMap,
+  Heap,
   MaxHeap,
   MaxPriorityQueue,
   MinHeap,
@@ -12,12 +14,25 @@ import {
   RedBlackTree,
   SinglyLinkedList,
   Stack,
-  TreeMultimap
+  TreeMultimap,
+  Trie
 } from '../../src';
 import { isDebugTest } from "../config";
 
 const isDebug = isDebugTest;
 const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+const orgStrArr: string[] = [
+  "trie",
+  "trial",
+  "trick",
+  "trip",
+  "tree",
+  "trend",
+  "triangle",
+  "track",
+  "trace",
+  "transmit"
+];
 const entries: [number, number][] = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
 
 describe('conversions', () => {
@@ -72,28 +87,69 @@ describe('conversions', () => {
   })
 
   it('Entry Array to BST', () => {
-    const bst = new BST<number>(orgArr);
+    const bst = new BST<number>(entries);
     expect(bst.size).toBe(9)
     isDebug && bst.print();
   })
 
   it('Entry Array to RedBlackTree', () => {
-    const rbTree = new RedBlackTree<number>(orgArr);
+    const rbTree = new RedBlackTree<number>(entries);
     expect(rbTree.size).toBe(9)
     isDebug && rbTree.print();
   })
 
   it('Entry Array to AVLTree', () => {
-    const avl = new AVLTree<number>(orgArr);
+    const avl = new AVLTree<number>(entries);
     expect(avl.size).toBe(9)
     isDebug && avl.print();
   })
 
   it('Entry Array to TreeMultimap', () => {
-    const treeMulti = new TreeMultimap<number>(orgArr);
+    const treeMulti = new TreeMultimap<number>(entries);
     expect(treeMulti.size).toBe(9)
     isDebug && treeMulti.print();
   })
+
+  it('HashMap to RedBlackTree', () => {
+    const hm = new HashMap(entries);
+    isDebug && hm.print()
+    const rbTree = new RedBlackTree<number>(hm);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('PriorityQueue to BST', () => {
+    const pq = new MinPriorityQueue(orgArr);
+    isDebug && pq.print();
+    const bst = new BST<number>(pq);
+    expect(bst.size).toBe(9)
+    isDebug && bst.print();
+  })
+
+  it('Deque to RedBlackTree', () => {
+    const dq = new Deque(orgArr);
+    isDebug && dq.print();
+    const rbTree = new RedBlackTree<number>(dq);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('Trie to Heap to Deque', () => {
+    const trie = new Trie(orgStrArr);
+    expect(trie.size).toBe(10);
+    isDebug && trie.print();
+    const heap = new Heap<string>(trie, { comparator: (a, b) => Number(a) - Number(b) });
+    expect(heap.size).toBe(10);
+    isDebug && heap.print();
+    const dq = new Deque<string>(heap);
+    expect(dq.size).toBe(10);
+    isDebug && dq.print();
+    const entries = dq.map((el, i) => <[number, string]>[i, el]);
+    const avl = new AVLTree<string>(entries);
+    expect(avl.size).toBe(10)
+    isDebug && avl.print();
+  })
+
 })
 
 

package/tsconfig-cjs.json

@@ -6,7 +6,7 @@
     "module": "CommonJS",
     "target": "ES2015",
     "moduleResolution": "node",
-    "sourceMap": true,
+    "sourceMap": true
   },
   "include": [
     "./src/**/*.ts"