diff --git a/.prettierignore b/.prettierignore index e459c2d..76e5fe5 100644 --- a/.prettierignore +++ b/.prettierignore @@ -2,4 +2,4 @@ src/types/data-structures/binary-tree/binary-tree.ts src/types/data-structures/binary-tree/bst.ts src/types/data-structures/binary-tree/avl-tree.ts src/types/data-structures/binary-tree/rb-tree.ts -src/types/data-structures/binary-tree/tree-multiset.ts +src/types/data-structures/binary-tree/tree-multimap.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ece9ac..412585f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file. - [Semantic Versioning](https://semver.org/spec/v2.0.0.html) - [`auto-changelog`](https://github.com/CookPete/auto-changelog) -## [v1.42.3](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming) +## [v1.42.4](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming) ### Changes diff --git a/README.md b/README.md index 7a24af6..7e1e85e 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ yarn add data-structure-typed ```js import { BinaryTree, Graph, Queue, Stack, PriorityQueue, BST, Trie, DoublyLinkedList, - AVLTree, MinHeap, SinglyLinkedList, DirectedGraph, TreeMultiset, + AVLTree, MinHeap, SinglyLinkedList, DirectedGraph, TreeMultimap, DirectedVertex, AVLTreeNode } from 'data-structure-typed'; ``` @@ -63,7 +63,7 @@ import { const {Heap} = dataStructureTyped; const { BinaryTree, Graph, Queue, Stack, PriorityQueue, BST, Trie, DoublyLinkedList, - AVLTree, MinHeap, SinglyLinkedList, DirectedGraph, TreeMultiset, + AVLTree, MinHeap, SinglyLinkedList, DirectedGraph, TreeMultimap, DirectedVertex, AVLTreeNode } = dataStructureTyped; ``` @@ -71,7 +71,7 @@ const { ![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/binary-tree-array-to-binary-tree.webp) ![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/binary-tree-dfs-in-order.webp) ![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/avl-tree-test.webp) -![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/tree-multiset-test.webp) +![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/tree-multimap-test.webp) ![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/matrix-cut-off-tree-for-golf.webp) ![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/directed-graph-test.webp) ![](https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/examples/videos/webp_output/map-graph-test.webp) @@ -290,7 +290,7 @@ Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id) // ['A', 'B', 'D Tree Multiset -TreeMultiset +TreeMultimap @@ -627,7 +627,7 @@ Opt for concise and clear method names, avoiding excessive length while ensuring ### Object-oriented programming(OOP) -By strictly adhering to object-oriented design (BinaryTree -> BST -> AVLTree -> TreeMultiset), you can seamlessly +By strictly adhering to object-oriented design (BinaryTree -> BST -> AVLTree -> TreeMultimap), you can seamlessly inherit the existing data structures to implement the customized ones you need. Object-oriented design stands as the optimal approach to data structure design. @@ -636,40 +636,40 @@ optimal approach to data structure design. [//]: # (Start of Replace Section)
avl-tree
-
test nametime taken (ms)executions per secsample deviation
10,000 add randomly30.3332.973.56e-4
10,000 add & delete randomly66.1015.130.00
10,000 addMany39.4425.353.62e-4
10,000 get27.0636.962.52e-4
+
test nametime taken (ms)executions per secsample deviation
10,000 add randomly30.5232.763.28e-4
10,000 add & delete randomly66.9614.940.00
10,000 addMany39.7825.143.67e-4
10,000 get27.3836.520.00
binary-tree
-
test nametime taken (ms)executions per secsample deviation
1,000 add randomly12.9077.521.09e-4
1,000 add & delete randomly16.1361.991.61e-4
1,000 addMany10.7493.091.00e-4
1,000 get18.0955.281.90e-4
1,000 dfs71.1214.067.83e-4
1,000 bfs57.2417.474.17e-4
1,000 morris37.2926.813.77e-4
+
test nametime taken (ms)executions per secsample deviation
1,000 add randomly10.5095.202.30e-4
1,000 add & delete randomly16.1861.812.48e-4
1,000 addMany10.8092.621.83e-4
1,000 get18.0355.451.41e-4
1,000 dfs157.866.330.00
1,000 bfs56.6817.640.00
1,000 morris37.2126.882.79e-4
bst
-
test nametime taken (ms)executions per secsample deviation
10,000 add randomly31.5831.670.00
10,000 add & delete randomly71.0914.078.99e-4
10,000 addMany29.6833.690.00
10,000 get28.5535.030.00
+
test nametime taken (ms)executions per secsample deviation
10,000 add randomly27.6136.214.73e-4
10,000 add & delete randomly62.9315.895.86e-4
10,000 addMany28.7034.840.00
10,000 get27.6736.142.92e-4
rb-tree
-
test nametime taken (ms)executions per secsample deviation
100,000 add randomly84.6411.820.01
100,000 add & 1000 delete randomly81.3212.300.01
100,000 getNode61.1816.350.00
+
test nametime taken (ms)executions per secsample deviation
100,000 add randomly87.5111.430.01
100,000 add & delete randomly189.065.290.01
100,000 getNode35.3328.318.93e-4
directed-graph
-
test nametime taken (ms)executions per secsample deviation
1,000 addVertex0.109637.473.79e-6
1,000 addEdge6.09164.181.31e-4
1,000 getVertex0.052.14e+41.35e-6
1,000 getEdge23.9141.820.01
tarjan218.654.570.01
tarjan all221.674.510.00
topologicalSort184.345.420.02
+
test nametime taken (ms)executions per secsample deviation
1,000 addVertex0.109899.918.58e-7
1,000 addEdge6.06165.021.68e-4
1,000 getVertex0.052.17e+44.22e-7
1,000 getEdge23.0543.380.00
tarjan222.594.490.01
tarjan all226.894.410.01
topologicalSort187.345.340.01
heap
-
test nametime taken (ms)executions per secsample deviation
10,000 add & pop4.63215.774.49e-5
10,000 fib add & pop355.192.820.00
+
test nametime taken (ms)executions per secsample deviation
10,000 add & pop4.66214.549.38e-5
10,000 fib add & pop364.302.740.01
doubly-linked-list
-
test nametime taken (ms)executions per secsample deviation
1,000,000 unshift213.534.680.02
1,000,000 unshift & shift162.976.140.02
1,000,000 insertBefore335.192.980.09
+
test nametime taken (ms)executions per secsample deviation
1,000,000 unshift243.614.100.07
1,000,000 unshift & shift173.325.770.03
1,000,000 insertBefore315.863.170.04
singly-linked-list
-
test nametime taken (ms)executions per secsample deviation
10,000 push & pop231.354.320.02
10,000 insertBefore251.493.980.01
+
test nametime taken (ms)executions per secsample deviation
10,000 push & pop228.064.380.03
10,000 insertBefore252.073.970.01
max-priority-queue
-
test nametime taken (ms)executions per secsample deviation
10,000 refill & poll11.4887.141.91e-4
+
test nametime taken (ms)executions per secsample deviation
10,000 refill & poll11.5386.712.27e-4
deque
-
test nametime taken (ms)executions per secsample deviation
1,000,000 push215.144.650.05
1,000,000 shift25.1539.760.00
+
test nametime taken (ms)executions per secsample deviation
1,000,000 push227.244.400.07
1,000,000 shift25.6039.070.00
queue
-
test nametime taken (ms)executions per secsample deviation
1,000,000 push44.1522.650.01
1,000,000 push & shift80.8712.370.00
+
test nametime taken (ms)executions per secsample deviation
1,000,000 push45.9821.750.01
1,000,000 push & shift81.1212.330.00
trie
-
test nametime taken (ms)executions per secsample deviation
100,000 push61.3816.290.01
100,000 getWords104.279.590.02
+
test nametime taken (ms)executions per secsample deviation
100,000 push59.4016.830.01
100,000 getWords90.0711.100.00
[//]: # (End of Replace Section) \ No newline at end of file diff --git a/package.json b/package.json index 8617e9e..f0d190a 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "data-structure-typed", - "version": "1.42.4", + "version": "1.42.5", "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.", "main": "dist/cjs/src/index.js", "module": "dist/mjs/src/index.js", @@ -30,7 +30,7 @@ "reformat:test": "npm run lint:test && npm run format:test", "reformat": "npm run reformat:src && npm run reformat:test", "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev", - "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev", + "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev", "test": "jest --runInBand", "test:integration": "npm run update:subs && jest --config jest.integration.config.js", "benchmark": "ts-node test/performance/reportor.ts", @@ -161,7 +161,7 @@ "avl-tree", "tree multiset", "treemultiset", - "tree-multiset", + "tree-multimap", "binary indexed tree", "binaryindexedtree", "binary-indexed-tree", diff --git a/scripts/copy_to_all_subs.sh b/scripts/copy_to_all_subs.sh index a12a000..de46d3c 100644 --- a/scripts/copy_to_all_subs.sh +++ b/scripts/copy_to_all_subs.sh @@ -28,7 +28,7 @@ directories=( "singly-linked-list-typed" "queue-typed" "stack-typed" - "tree-multiset-typed" + "tree-multimap-typed" "trie-typed" "undirected-graph-typed" ) diff --git a/scripts/publish_all_subs.sh b/scripts/publish_all_subs.sh index 7b7da2f..df40d67 100755 --- a/scripts/publish_all_subs.sh +++ b/scripts/publish_all_subs.sh @@ -46,7 +46,7 @@ directories=( "singly-linked-list-typed" "queue-typed" "stack-typed" - "tree-multiset-typed" + "tree-multimap-typed" "trie-typed" "undirected-graph-typed" ) diff --git a/scripts/run_command_all_subs.sh b/scripts/run_command_all_subs.sh index 389bfa8..3e3b075 100755 --- a/scripts/run_command_all_subs.sh +++ b/scripts/run_command_all_subs.sh @@ -42,7 +42,7 @@ directories=( "singly-linked-list-typed" "queue-typed" "stack-typed" - "tree-multiset-typed" + "tree-multimap-typed" "trie-typed" "undirected-graph-typed" ) diff --git a/src/data-structures/binary-tree/index.ts b/src/data-structures/binary-tree/index.ts index 87b06d3..05f0f9b 100644 --- a/src/data-structures/binary-tree/index.ts +++ b/src/data-structures/binary-tree/index.ts @@ -4,4 +4,4 @@ export * from './binary-indexed-tree'; export * from './segment-tree'; export * from './avl-tree'; export * from './rb-tree'; -export * from './tree-multiset'; +export * from './tree-multimap'; diff --git a/src/data-structures/binary-tree/tree-multiset.ts b/src/data-structures/binary-tree/tree-multimap.ts similarity index 95% rename from src/data-structures/binary-tree/tree-multiset.ts rename to src/data-structures/binary-tree/tree-multimap.ts index bb0c505..7b13e84 100644 --- a/src/data-structures/binary-tree/tree-multiset.ts +++ b/src/data-structures/binary-tree/tree-multimap.ts @@ -5,14 +5,14 @@ * @copyright Copyright (c) 2022 Tyler Zeng * @license MIT License */ -import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types'; +import type {BTNKey, TreeMultimapNodeNested, TreeMultimapOptions} from '../../types'; import {BinaryTreeDeletedResult, BTNCallback, CP, FamilyPosition, IterationType} from '../../types'; import {IBinaryTree} from '../../interfaces'; import {AVLTree, AVLTreeNode} from './avl-tree'; -export class TreeMultisetNode< +export class TreeMultimapNode< V = any, - N extends TreeMultisetNode = TreeMultisetNodeNested + N extends TreeMultimapNode = TreeMultimapNodeNested > extends AVLTreeNode { count: number; @@ -33,19 +33,19 @@ export class TreeMultisetNode< } /** - * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters. + * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters. */ -export class TreeMultiset = TreeMultisetNode>> +export class TreeMultimap = TreeMultimapNode>> extends AVLTree implements IBinaryTree { /** - * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to + * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to * merge duplicated values. - * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the - * TreeMultiset. + * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the + * TreeMultimap. */ - constructor(options?: TreeMultisetOptions) { + constructor(options?: TreeMultimapOptions) { super(options); } @@ -65,7 +65,7 @@ export class TreeMultiset = TreeMultis * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided). */ override createNode(key: BTNKey, value?: V, count?: number): N { - return new TreeMultisetNode(key, value, count) as N; + return new TreeMultimapNode(key, value, count) as N; } /** @@ -85,7 +85,7 @@ export class TreeMultiset = TreeMultis if(keyOrNode === null) return undefined; let inserted: N | undefined = undefined, newNode: N | undefined; - if (keyOrNode instanceof TreeMultisetNode) { + if (keyOrNode instanceof TreeMultimapNode) { newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count); } else if (keyOrNode === undefined) { newNode = undefined; @@ -184,10 +184,10 @@ export class TreeMultiset = TreeMultis } /** - * The `addMany` function adds multiple keys or nodes to a TreeMultiset and returns an array of the + * The `addMany` function adds multiple keys or nodes to a TreeMultimap and returns an array of the * inserted nodes. * @param {(BTNKey | undefined)[] | (N | undefined)[]} keysOrNodes - An array of keys or nodes to be - * added to the multiset. Each element can be either a BTNKey or a TreeMultisetNode. + * added to the multiset. Each element can be either a BTNKey or a TreeMultimapNode. * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond * to the keys or nodes being added to the multiset. It is used to associate additional data with * each key or node. @@ -199,7 +199,7 @@ export class TreeMultiset = TreeMultis for (let i = 0; i < keysOrNodes.length; i++) { const keyOrNode = keysOrNodes[i]; - if (keyOrNode instanceof TreeMultisetNode) { + if (keyOrNode instanceof TreeMultimapNode) { inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count)); continue; } diff --git a/src/types/data-structures/binary-tree/index.ts b/src/types/data-structures/binary-tree/index.ts index 6c81aa6..ea30893 100644 --- a/src/types/data-structures/binary-tree/index.ts +++ b/src/types/data-structures/binary-tree/index.ts @@ -2,5 +2,5 @@ export * from './binary-tree'; export * from './bst'; export * from './avl-tree'; export * from './segment-tree'; -export * from './tree-multiset'; +export * from './tree-multimap'; export * from './rb-tree'; diff --git a/src/types/data-structures/binary-tree/tree-multimap.ts b/src/types/data-structures/binary-tree/tree-multimap.ts new file mode 100644 index 0000000..d2fcf54 --- /dev/null +++ b/src/types/data-structures/binary-tree/tree-multimap.ts @@ -0,0 +1,6 @@ +import {TreeMultimapNode} from '../../../data-structures'; +import {AVLTreeOptions} from './avl-tree'; + +export type TreeMultimapNodeNested = TreeMultimapNode>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +export type TreeMultimapOptions = Omit & {} diff --git a/src/types/data-structures/binary-tree/tree-multiset.ts b/src/types/data-structures/binary-tree/tree-multiset.ts deleted file mode 100644 index ad14629..0000000 --- a/src/types/data-structures/binary-tree/tree-multiset.ts +++ /dev/null @@ -1,6 +0,0 @@ -import {TreeMultisetNode} from '../../../data-structures'; -import {AVLTreeOptions} from './avl-tree'; - -export type TreeMultisetNodeNested = TreeMultisetNode>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - -export type TreeMultisetOptions = Omit & {} diff --git a/test/performance/data-structures/binary-tree/rb-tree.test.ts b/test/performance/data-structures/binary-tree/rb-tree.test.ts index a3da096..34b4532 100644 --- a/test/performance/data-structures/binary-tree/rb-tree.test.ts +++ b/test/performance/data-structures/binary-tree/rb-tree.test.ts @@ -14,12 +14,12 @@ suite rbTree.add(arr[i]); } }) - .add(`${HUNDRED_THOUSAND.toLocaleString()} add & 1000 delete randomly`, () => { + .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => { rbTree.clear(); for (let i = 0; i < arr.length; i++) { rbTree.add(arr[i]); } - for (let i = 0; i < 1000; i++) { + for (let i = 0; i < arr.length; i++) { rbTree.delete(arr[i]); } }) diff --git a/test/performance/data-structures/binary-tree/tree-multiset.test.ts b/test/performance/data-structures/binary-tree/tree-multimap.test.ts similarity index 100% rename from test/performance/data-structures/binary-tree/tree-multiset.test.ts rename to test/performance/data-structures/binary-tree/tree-multimap.test.ts diff --git a/test/unit/data-structures/binary-tree/tree-multiset.test.ts b/test/unit/data-structures/binary-tree/tree-multimap.test.ts similarity index 51% rename from test/unit/data-structures/binary-tree/tree-multiset.test.ts rename to test/unit/data-structures/binary-tree/tree-multimap.test.ts index b61fdf6..b4d76f1 100644 --- a/test/unit/data-structures/binary-tree/tree-multiset.test.ts +++ b/test/unit/data-structures/binary-tree/tree-multimap.test.ts @@ -1,216 +1,216 @@ -import {CP, IterationType, TreeMultiset, TreeMultisetNode} from '../../../../src'; +import {CP, IterationType, TreeMultimap, TreeMultimapNode} from '../../../../src'; import {isDebugTest} from '../../../config'; const isDebug = isDebugTest; -describe('TreeMultiset operations test', () => { +describe('TreeMultimap operations test', () => { it('should perform various operations on a Binary Search Tree with numeric values', () => { - const treeMultiset = new TreeMultiset(); + const treeMultimap = new TreeMultimap(); - expect(treeMultiset instanceof TreeMultiset); - treeMultiset.add(11, 11); - treeMultiset.add(3, 3); + 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]; - treeMultiset.addMany(idAndValues, idAndValues); - expect(treeMultiset.root instanceof TreeMultisetNode); + treeMultimap.addMany(idAndValues, idAndValues); + expect(treeMultimap.root instanceof TreeMultimapNode); - if (treeMultiset.root) expect(treeMultiset.root.key == 11); + if (treeMultimap.root) expect(treeMultimap.root.key == 11); - expect(treeMultiset.size).toBe(16); - expect(treeMultiset.count).toBe(18); + expect(treeMultimap.size).toBe(16); + expect(treeMultimap.count).toBe(18); - expect(treeMultiset.has(6)); + expect(treeMultimap.has(6)); - expect(treeMultiset.getHeight(6)).toBe(3); - expect(treeMultiset.getDepth(6)).toBe(1); - const nodeId10 = treeMultiset.getNode(10); + expect(treeMultimap.getHeight(6)).toBe(3); + expect(treeMultimap.getDepth(6)).toBe(1); + const nodeId10 = treeMultimap.getNode(10); expect(nodeId10?.key).toBe(10); - const nodeVal9 = treeMultiset.getNode(9, node => node.value); + const nodeVal9 = treeMultimap.getNode(9, node => node.value); expect(nodeVal9?.key).toBe(9); - const nodesByCount1 = treeMultiset.getNodes(1, node => node.count); + const nodesByCount1 = treeMultimap.getNodes(1, node => node.count); expect(nodesByCount1.length).toBe(14); - const nodesByCount2 = treeMultiset.getNodes(2, node => node.count); + const nodesByCount2 = treeMultimap.getNodes(2, node => node.count); expect(nodesByCount2.length).toBe(2); - const leftMost = treeMultiset.getLeftMost(); + const leftMost = treeMultimap.getLeftMost(); expect(leftMost?.key).toBe(1); - const node15 = treeMultiset.getNode(15); - const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15); + const node15 = treeMultimap.getNode(15); + const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15); expect(minNodeBySpecificNode?.key).toBe(12); let subTreeSum = 0; - node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode) => (subTreeSum += node.key), 15); + node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode) => (subTreeSum += node.key), 15); expect(subTreeSum).toBe(70); let lesserSum = 0; - treeMultiset.lesserOrGreaterTraverse((node: TreeMultisetNode) => (lesserSum += node.key), CP.lt, 10); + treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode) => (lesserSum += node.key), CP.lt, 10); expect(lesserSum).toBe(45); - expect(node15 instanceof TreeMultisetNode); - if (node15 instanceof TreeMultisetNode) { - const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode) => (node.count += 1), 15); + expect(node15 instanceof TreeMultimapNode); + if (node15 instanceof TreeMultimapNode) { + const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode) => (node.count += 1), 15); expect(subTreeAdd); } - const node11 = treeMultiset.getNode(11); - expect(node11 instanceof TreeMultisetNode); - if (node11 instanceof TreeMultisetNode) { - const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11); + const node11 = treeMultimap.getNode(11); + expect(node11 instanceof TreeMultimapNode); + if (node11 instanceof TreeMultimapNode) { + const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11); expect(allGreaterNodesAdded); } - const dfsInorderNodes = treeMultiset.dfs(node => node, 'in'); + const dfsInorderNodes = treeMultimap.dfs(node => node, 'in'); expect(dfsInorderNodes[0].key).toBe(1); expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16); - expect(treeMultiset.isPerfectlyBalanced()).toBe(false); + expect(treeMultimap.isPerfectlyBalanced()).toBe(false); - treeMultiset.perfectlyBalance(); + treeMultimap.perfectlyBalance(); - expect(treeMultiset.isPerfectlyBalanced()).toBe(true); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isPerfectlyBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - const bfsNodesAfterBalanced = treeMultiset.bfs(node => node); + const bfsNodesAfterBalanced = treeMultimap.bfs(node => node); expect(bfsNodesAfterBalanced[0].key).toBe(8); expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16); - const removed11 = treeMultiset.delete(11, undefined, true); + const removed11 = treeMultimap.delete(11, undefined, true); expect(removed11 instanceof Array); expect(removed11[0]); expect(removed11[0].deleted); if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight(15)).toBe(1); + expect(treeMultimap.getHeight(15)).toBe(1); - const removed1 = treeMultiset.delete(1, undefined, true); + const removed1 = treeMultimap.delete(1, undefined, true); expect(removed1 instanceof Array); expect(removed1[0]); expect(removed1[0].deleted); if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(4); + expect(treeMultimap.getHeight()).toBe(4); - const removed4 = treeMultiset.delete(4, undefined, true); + const removed4 = treeMultimap.delete(4, undefined, true); expect(removed4 instanceof Array); expect(removed4[0]); expect(removed4[0].deleted); if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(4); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(4); - const removed10 = treeMultiset.delete(10, undefined, true); + const removed10 = treeMultimap.delete(10, undefined, true); expect(removed10 instanceof Array); expect(removed10[0]); expect(removed10[0].deleted); if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.getHeight()).toBe(3); - const removed15 = treeMultiset.delete(15, undefined, true); + const removed15 = treeMultimap.delete(15, undefined, true); expect(removed15 instanceof Array); expect(removed15[0]); expect(removed15[0].deleted); if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed5 = treeMultiset.delete(5, undefined, true); + const removed5 = treeMultimap.delete(5, undefined, true); expect(removed5 instanceof Array); expect(removed5[0]); expect(removed5[0].deleted); if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed13 = treeMultiset.delete(13, undefined, true); + const removed13 = treeMultimap.delete(13, undefined, true); expect(removed13 instanceof Array); expect(removed13[0]); expect(removed13[0].deleted); if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed3 = treeMultiset.delete(3, undefined, true); + const removed3 = treeMultimap.delete(3, undefined, true); expect(removed3 instanceof Array); expect(removed3[0]); expect(removed3[0].deleted); if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed8 = treeMultiset.delete(8, undefined, true); + const removed8 = treeMultimap.delete(8, undefined, true); expect(removed8 instanceof Array); expect(removed8[0]); expect(removed8[0].deleted); if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed6 = treeMultiset.delete(6, undefined, true); + const removed6 = treeMultimap.delete(6, undefined, true); expect(removed6 instanceof Array); expect(removed6[0]); expect(removed6[0].deleted); if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6); - expect(treeMultiset.delete(6, undefined, true).length).toBe(0); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.delete(6, undefined, true).length).toBe(0); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(2); + expect(treeMultimap.getHeight()).toBe(2); - const removed7 = treeMultiset.delete(7, undefined, true); + const removed7 = treeMultimap.delete(7, undefined, true); expect(removed7 instanceof Array); expect(removed7[0]); expect(removed7[0].deleted); if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(2); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(2); - const removed9 = treeMultiset.delete(9, undefined, true); + const removed9 = treeMultimap.delete(9, undefined, true); expect(removed9 instanceof Array); expect(removed9[0]); expect(removed9[0].deleted); if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(2); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(2); - const removed14 = treeMultiset.delete(14, undefined, true); + const removed14 = treeMultimap.delete(14, undefined, true); expect(removed14 instanceof Array); expect(removed14[0]); expect(removed14[0].deleted); if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(1); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(1); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - const bfsIDs = treeMultiset.bfs(node => node.key); + const bfsIDs = treeMultimap.bfs(node => node.key); expect(bfsIDs[0]).toBe(12); expect(bfsIDs[1]).toBe(2); expect(bfsIDs[2]).toBe(16); - const bfsNodes = treeMultiset.bfs(node => node); + 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(treeMultiset.count).toBe(9); + expect(treeMultimap.count).toBe(9); }); it('should perform various operations on a Binary Search Tree with object values', () => { - const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>(); - expect(objTreeMultiset).toBeInstanceOf(TreeMultiset); - objTreeMultiset.add(11, {key: 11, keyA: 11}); - objTreeMultiset.add(3, {key: 3, keyA: 3}); + 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}, @@ -228,229 +228,229 @@ describe('TreeMultiset operations test', () => { {key: 5, keyA: 5} ]; - objTreeMultiset.addMany( + objTreeMultimap.addMany( values.map(item => item.key), values ); - expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode); + expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode); - if (objTreeMultiset.root) expect(objTreeMultiset.root.key).toBe(11); + if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11); - expect(objTreeMultiset.count).toBe(16); + expect(objTreeMultimap.count).toBe(16); - expect(objTreeMultiset.has(6)).toBe(true); + expect(objTreeMultimap.has(6)).toBe(true); }); }); -describe('TreeMultiset operations test recursively', () => { +describe('TreeMultimap operations test recursively', () => { it('should perform various operations on a Binary Search Tree with numeric values', () => { - const treeMultiset = new TreeMultiset({iterationType: IterationType.RECURSIVE}); + const treeMultimap = new TreeMultimap({iterationType: IterationType.RECURSIVE}); - expect(treeMultiset instanceof TreeMultiset); - treeMultiset.add(11, 11); - treeMultiset.add(3, 3); + 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]; - treeMultiset.addMany(idAndValues, idAndValues); - expect(treeMultiset.root instanceof TreeMultisetNode); + treeMultimap.addMany(idAndValues, idAndValues); + expect(treeMultimap.root instanceof TreeMultimapNode); - if (treeMultiset.root) expect(treeMultiset.root.key == 11); + if (treeMultimap.root) expect(treeMultimap.root.key == 11); - expect(treeMultiset.size).toBe(16); - expect(treeMultiset.count).toBe(18); + expect(treeMultimap.size).toBe(16); + expect(treeMultimap.count).toBe(18); - expect(treeMultiset.has(6)); + expect(treeMultimap.has(6)); - expect(treeMultiset.getHeight(6)).toBe(3); - expect(treeMultiset.getDepth(6)).toBe(1); - const nodeId10 = treeMultiset.getNode(10); + expect(treeMultimap.getHeight(6)).toBe(3); + expect(treeMultimap.getDepth(6)).toBe(1); + const nodeId10 = treeMultimap.getNode(10); expect(nodeId10?.key).toBe(10); - const nodeVal9 = treeMultiset.getNode(9, node => node.value); + const nodeVal9 = treeMultimap.getNode(9, node => node.value); expect(nodeVal9?.key).toBe(9); - const nodesByCount1 = treeMultiset.getNodes(1, node => node.count); + const nodesByCount1 = treeMultimap.getNodes(1, node => node.count); expect(nodesByCount1.length).toBe(14); - const nodesByCount2 = treeMultiset.getNodes(2, node => node.count); + const nodesByCount2 = treeMultimap.getNodes(2, node => node.count); expect(nodesByCount2.length).toBe(2); - const leftMost = treeMultiset.getLeftMost(); + const leftMost = treeMultimap.getLeftMost(); expect(leftMost?.key).toBe(1); - const node15 = treeMultiset.getNode(15); - const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15); + const node15 = treeMultimap.getNode(15); + const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15); expect(minNodeBySpecificNode?.key).toBe(12); let subTreeSum = 0; - node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode) => (subTreeSum += node.key), 15); + node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode) => (subTreeSum += node.key), 15); expect(subTreeSum).toBe(70); let lesserSum = 0; - treeMultiset.lesserOrGreaterTraverse((node: TreeMultisetNode) => (lesserSum += node.key), CP.lt, 10); + treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode) => (lesserSum += node.key), CP.lt, 10); expect(lesserSum).toBe(45); - expect(node15 instanceof TreeMultisetNode); - if (node15 instanceof TreeMultisetNode) { - const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode) => (node.count += 1), 15); + expect(node15 instanceof TreeMultimapNode); + if (node15 instanceof TreeMultimapNode) { + const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode) => (node.count += 1), 15); expect(subTreeAdd); } - const node11 = treeMultiset.getNode(11); - expect(node11 instanceof TreeMultisetNode); - if (node11 instanceof TreeMultisetNode) { - const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11); + const node11 = treeMultimap.getNode(11); + expect(node11 instanceof TreeMultimapNode); + if (node11 instanceof TreeMultimapNode) { + const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11); expect(allGreaterNodesAdded); } - const dfsInorderNodes = treeMultiset.dfs(node => node, 'in'); + const dfsInorderNodes = treeMultimap.dfs(node => node, 'in'); expect(dfsInorderNodes[0].key).toBe(1); expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16); - expect(treeMultiset.isPerfectlyBalanced()).toBe(false); + expect(treeMultimap.isPerfectlyBalanced()).toBe(false); - treeMultiset.perfectlyBalance(); + treeMultimap.perfectlyBalance(); - expect(treeMultiset.isPerfectlyBalanced()).toBe(true); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isPerfectlyBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - const bfsNodesAfterBalanced = treeMultiset.bfs(node => node); + const bfsNodesAfterBalanced = treeMultimap.bfs(node => node); expect(bfsNodesAfterBalanced[0].key).toBe(8); expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16); - const removed11 = treeMultiset.delete(11, undefined, true); + const removed11 = treeMultimap.delete(11, undefined, true); expect(removed11 instanceof Array); expect(removed11[0]); expect(removed11[0].deleted); if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight(15)).toBe(1); + expect(treeMultimap.getHeight(15)).toBe(1); - const removed1 = treeMultiset.delete(1, undefined, true); + const removed1 = treeMultimap.delete(1, undefined, true); expect(removed1 instanceof Array); expect(removed1[0]); expect(removed1[0].deleted); if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(4); + expect(treeMultimap.getHeight()).toBe(4); - const removed4 = treeMultiset.delete(4, undefined, true); + const removed4 = treeMultimap.delete(4, undefined, true); expect(removed4 instanceof Array); expect(removed4[0]); expect(removed4[0].deleted); if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(4); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(4); - const removed10 = treeMultiset.delete(10, undefined, true); + const removed10 = treeMultimap.delete(10, undefined, true); expect(removed10 instanceof Array); expect(removed10[0]); expect(removed10[0].deleted); if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.getHeight()).toBe(3); - const removed15 = treeMultiset.delete(15, undefined, true); + const removed15 = treeMultimap.delete(15, undefined, true); expect(removed15 instanceof Array); expect(removed15[0]); expect(removed15[0].deleted); if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed5 = treeMultiset.delete(5, undefined, true); + const removed5 = treeMultimap.delete(5, undefined, true); expect(removed5 instanceof Array); expect(removed5[0]); expect(removed5[0].deleted); if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed13 = treeMultiset.delete(13, undefined, true); + const removed13 = treeMultimap.delete(13, undefined, true); expect(removed13 instanceof Array); expect(removed13[0]); expect(removed13[0].deleted); if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed3 = treeMultiset.delete(3, undefined, true); + const removed3 = treeMultimap.delete(3, undefined, true); expect(removed3 instanceof Array); expect(removed3[0]); expect(removed3[0].deleted); if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed8 = treeMultiset.delete(8, undefined, true); + const removed8 = treeMultimap.delete(8, undefined, true); expect(removed8 instanceof Array); expect(removed8[0]); expect(removed8[0].deleted); if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(3); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(3); - const removed6 = treeMultiset.delete(6, undefined, true); + const removed6 = treeMultimap.delete(6, undefined, true); expect(removed6 instanceof Array); expect(removed6[0]); expect(removed6[0].deleted); if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6); - expect(treeMultiset.delete(6, undefined, true).length).toBe(0); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.delete(6, undefined, true).length).toBe(0); + expect(treeMultimap.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(2); + expect(treeMultimap.getHeight()).toBe(2); - const removed7 = treeMultiset.delete(7, undefined, true); + const removed7 = treeMultimap.delete(7, undefined, true); expect(removed7 instanceof Array); expect(removed7[0]); expect(removed7[0].deleted); if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(2); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(2); - const removed9 = treeMultiset.delete(9, undefined, true); + const removed9 = treeMultimap.delete(9, undefined, true); expect(removed9 instanceof Array); expect(removed9[0]); expect(removed9[0].deleted); if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(2); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(2); - const removed14 = treeMultiset.delete(14, undefined, true); + const removed14 = treeMultimap.delete(14, undefined, true); expect(removed14 instanceof Array); expect(removed14[0]); expect(removed14[0].deleted); if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14); - expect(treeMultiset.isAVLBalanced()).toBe(true); - expect(treeMultiset.getHeight()).toBe(1); + expect(treeMultimap.isAVLBalanced()).toBe(true); + expect(treeMultimap.getHeight()).toBe(1); - expect(treeMultiset.isAVLBalanced()).toBe(true); + expect(treeMultimap.isAVLBalanced()).toBe(true); - const bfsIDs = treeMultiset.bfs(node => node.key); + const bfsIDs = treeMultimap.bfs(node => node.key); expect(bfsIDs[0]).toBe(12); expect(bfsIDs[1]).toBe(2); expect(bfsIDs[2]).toBe(16); - const bfsNodes = treeMultiset.bfs(node => node); + 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(treeMultiset.count).toBe(9); + expect(treeMultimap.count).toBe(9); }); it('should perform various operations on a Binary Search Tree with object values', () => { - const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>(); - expect(objTreeMultiset).toBeInstanceOf(TreeMultiset); - objTreeMultiset.add(11, {key: 11, keyA: 11}); - objTreeMultiset.add(3, {key: 3, keyA: 3}); + 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}, @@ -468,29 +468,29 @@ describe('TreeMultiset operations test recursively', () => { {key: 5, keyA: 5} ]; - objTreeMultiset.addMany( + objTreeMultimap.addMany( values.map(item => item.key), values ); - expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode); + expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode); - if (objTreeMultiset.root) expect(objTreeMultiset.root.key).toBe(11); + if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11); - expect(objTreeMultiset.count).toBe(16); + expect(objTreeMultimap.count).toBe(16); - expect(objTreeMultiset.has(6)).toBe(true); + expect(objTreeMultimap.has(6)).toBe(true); }); }); -describe('TreeMultiset Performance test', function () { - const treeMS = new TreeMultiset>(); +describe('TreeMultimap Performance test', function () { + const treeMS = new TreeMultimap>(); const inputSize = 100000; // Adjust input sizes as needed beforeEach(() => { treeMS.clear(); }); - it(`Observe the time consumption of TreeMultiset.add fitting O(n log n)`, function () { + it(`Observe the time consumption of TreeMultimap.add fitting O(n log n)`, function () { // // Create a benchmark suite // const suite = new Benchmark.Suite(); // // Define a function to generate a random array of a given size @@ -503,7 +503,7 @@ describe('TreeMultiset Performance test', function () { // } // const inputArray = generateRandomArray(inputSize[0]); // - // suite.add(`TreeMultiset addMany (n=${inputSize[0]})`, () => { + // suite.add(`TreeMultimap addMany (n=${inputSize[0]})`, () => { // treeMS.addMany([...inputArray]); // }); // @@ -523,7 +523,7 @@ describe('TreeMultiset Performance test', function () { // .run({async: true}); }); - it(`Observe the time consumption of TreeMultiset.dfs be good`, function () { + it(`Observe the time consumption of TreeMultimap.dfs be good`, function () { const startDFS = performance.now(); const dfs = treeMS.dfs(node => node); isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);