data-structure-typed 1.42.4 → 1.42.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. package/CHANGELOG.md +1 -1
  2. package/README.md +17 -17
  3. package/benchmark/report.html +12 -12
  4. package/benchmark/report.json +106 -106
  5. package/dist/cjs/src/data-structures/binary-tree/index.d.ts +1 -1
  6. package/dist/cjs/src/data-structures/binary-tree/index.js +1 -1
  7. package/dist/cjs/src/data-structures/binary-tree/{tree-multiset.d.ts → tree-multimap.d.ts} +10 -10
  8. package/dist/cjs/src/data-structures/binary-tree/{tree-multiset.js → tree-multimap.js} +15 -15
  9. package/dist/cjs/src/data-structures/binary-tree/{tree-multiset.js.map → tree-multimap.js.map} +1 -1
  10. package/dist/cjs/src/types/data-structures/binary-tree/index.d.ts +1 -1
  11. package/dist/cjs/src/types/data-structures/binary-tree/index.js +1 -1
  12. package/dist/cjs/src/types/data-structures/binary-tree/tree-multimap.d.ts +4 -0
  13. package/dist/cjs/src/types/data-structures/binary-tree/{tree-multiset.js → tree-multimap.js} +1 -1
  14. package/dist/cjs/src/types/data-structures/binary-tree/tree-multimap.js.map +1 -0
  15. package/dist/mjs/src/data-structures/binary-tree/index.d.ts +1 -1
  16. package/dist/mjs/src/data-structures/binary-tree/index.js +1 -1
  17. package/dist/mjs/src/data-structures/binary-tree/{tree-multiset.d.ts → tree-multimap.d.ts} +10 -10
  18. package/dist/mjs/src/data-structures/binary-tree/{tree-multiset.js → tree-multimap.js} +14 -14
  19. package/dist/mjs/src/types/data-structures/binary-tree/index.d.ts +1 -1
  20. package/dist/mjs/src/types/data-structures/binary-tree/index.js +1 -1
  21. package/dist/mjs/src/types/data-structures/binary-tree/tree-multimap.d.ts +4 -0
  22. package/dist/umd/data-structure-typed.min.js +1 -1
  23. package/dist/umd/data-structure-typed.min.js.map +1 -1
  24. package/package.json +5 -3
  25. package/src/data-structures/binary-tree/index.ts +1 -1
  26. package/src/data-structures/binary-tree/{tree-multiset.ts → tree-multimap.ts} +14 -14
  27. package/src/types/data-structures/binary-tree/index.ts +1 -1
  28. package/src/types/data-structures/binary-tree/tree-multimap.ts +6 -0
  29. package/test/performance/data-structures/binary-tree/rb-tree.test.ts +2 -2
  30. package/test/unit/data-structures/binary-tree/{tree-multiset.test.ts → tree-multimap.test.ts} +182 -182
  31. package/dist/cjs/src/types/data-structures/binary-tree/tree-multiset.d.ts +0 -4
  32. package/dist/cjs/src/types/data-structures/binary-tree/tree-multiset.js.map +0 -1
  33. package/dist/mjs/src/types/data-structures/binary-tree/tree-multiset.d.ts +0 -4
  34. package/src/types/data-structures/binary-tree/tree-multiset.ts +0 -6
  35. /package/dist/mjs/src/types/data-structures/binary-tree/{tree-multiset.js → tree-multimap.js} +0 -0
  36. /package/test/performance/data-structures/binary-tree/{tree-multiset.test.ts → tree-multimap.test.ts} +0 -0
package/test/unit/data-structures/binary-tree/{tree-multiset.test.ts → tree-multimap.test.ts} RENAMED
@@ -1,216 +1,216 @@
1
- import {CP, IterationType, TreeMultiset, TreeMultisetNode} from '../../../../src';
1
+ import {CP, IterationType, TreeMultimap, TreeMultimapNode} from '../../../../src';
2
2
  import {isDebugTest} from '../../../config';
3
3
 
4
4
  const isDebug = isDebugTest;
5
5
 
6
- describe('TreeMultiset operations test', () => {
6
+ describe('TreeMultimap operations test', () => {
7
7
  it('should perform various operations on a Binary Search Tree with numeric values', () => {
8
- const treeMultiset = new TreeMultiset();
8
+ const treeMultimap = new TreeMultimap();
9
9
 
10
- expect(treeMultiset instanceof TreeMultiset);
11
- treeMultiset.add(11, 11);
12
- treeMultiset.add(3, 3);
10
+ expect(treeMultimap instanceof TreeMultimap);
11
+ treeMultimap.add(11, 11);
12
+ treeMultimap.add(3, 3);
13
13
  const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
14
- treeMultiset.addMany(idAndValues, idAndValues);
15
- expect(treeMultiset.root instanceof TreeMultisetNode);
14
+ treeMultimap.addMany(idAndValues, idAndValues);
15
+ expect(treeMultimap.root instanceof TreeMultimapNode);
16
16
 
17
- if (treeMultiset.root) expect(treeMultiset.root.key == 11);
17
+ if (treeMultimap.root) expect(treeMultimap.root.key == 11);
18
18
 
19
- expect(treeMultiset.size).toBe(16);
20
- expect(treeMultiset.count).toBe(18);
19
+ expect(treeMultimap.size).toBe(16);
20
+ expect(treeMultimap.count).toBe(18);
21
21
 
22
- expect(treeMultiset.has(6));
22
+ expect(treeMultimap.has(6));
23
23
 
24
- expect(treeMultiset.getHeight(6)).toBe(3);
25
- expect(treeMultiset.getDepth(6)).toBe(1);
26
- const nodeId10 = treeMultiset.getNode(10);
24
+ expect(treeMultimap.getHeight(6)).toBe(3);
25
+ expect(treeMultimap.getDepth(6)).toBe(1);
26
+ const nodeId10 = treeMultimap.getNode(10);
27
27
  expect(nodeId10?.key).toBe(10);
28
28
 
29
- const nodeVal9 = treeMultiset.getNode(9, node => node.value);
29
+ const nodeVal9 = treeMultimap.getNode(9, node => node.value);
30
30
  expect(nodeVal9?.key).toBe(9);
31
31
 
32
- const nodesByCount1 = treeMultiset.getNodes(1, node => node.count);
32
+ const nodesByCount1 = treeMultimap.getNodes(1, node => node.count);
33
33
  expect(nodesByCount1.length).toBe(14);
34
34
 
35
- const nodesByCount2 = treeMultiset.getNodes(2, node => node.count);
35
+ const nodesByCount2 = treeMultimap.getNodes(2, node => node.count);
36
36
  expect(nodesByCount2.length).toBe(2);
37
- const leftMost = treeMultiset.getLeftMost();
37
+ const leftMost = treeMultimap.getLeftMost();
38
38
  expect(leftMost?.key).toBe(1);
39
39
 
40
- const node15 = treeMultiset.getNode(15);
41
- const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
40
+ const node15 = treeMultimap.getNode(15);
41
+ const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
42
42
  expect(minNodeBySpecificNode?.key).toBe(12);
43
43
 
44
44
  let subTreeSum = 0;
45
- node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (subTreeSum += node.key), 15);
45
+ node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
46
46
  expect(subTreeSum).toBe(70);
47
47
  let lesserSum = 0;
48
- treeMultiset.lesserOrGreaterTraverse((node: TreeMultisetNode<number>) => (lesserSum += node.key), CP.lt, 10);
48
+ treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
49
49
  expect(lesserSum).toBe(45);
50
50
 
51
- expect(node15 instanceof TreeMultisetNode);
52
- if (node15 instanceof TreeMultisetNode) {
53
- const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (node.count += 1), 15);
51
+ expect(node15 instanceof TreeMultimapNode);
52
+ if (node15 instanceof TreeMultimapNode) {
53
+ const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (node.count += 1), 15);
54
54
  expect(subTreeAdd);
55
55
  }
56
- const node11 = treeMultiset.getNode(11);
57
- expect(node11 instanceof TreeMultisetNode);
58
- if (node11 instanceof TreeMultisetNode) {
59
- const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
56
+ const node11 = treeMultimap.getNode(11);
57
+ expect(node11 instanceof TreeMultimapNode);
58
+ if (node11 instanceof TreeMultimapNode) {
59
+ const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
60
60
  expect(allGreaterNodesAdded);
61
61
  }
62
62
 
63
- const dfsInorderNodes = treeMultiset.dfs(node => node, 'in');
63
+ const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
64
64
  expect(dfsInorderNodes[0].key).toBe(1);
65
65
  expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
66
- expect(treeMultiset.isPerfectlyBalanced()).toBe(false);
66
+ expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
67
67
 
68
- treeMultiset.perfectlyBalance();
68
+ treeMultimap.perfectlyBalance();
69
69
 
70
- expect(treeMultiset.isPerfectlyBalanced()).toBe(true);
71
- expect(treeMultiset.isAVLBalanced()).toBe(true);
70
+ expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
71
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
72
72
 
73
- const bfsNodesAfterBalanced = treeMultiset.bfs(node => node);
73
+ const bfsNodesAfterBalanced = treeMultimap.bfs(node => node);
74
74
  expect(bfsNodesAfterBalanced[0].key).toBe(8);
75
75
  expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
76
76
 
77
- const removed11 = treeMultiset.delete(11, undefined, true);
77
+ const removed11 = treeMultimap.delete(11, undefined, true);
78
78
  expect(removed11 instanceof Array);
79
79
  expect(removed11[0]);
80
80
  expect(removed11[0].deleted);
81
81
 
82
82
  if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
83
83
 
84
- expect(treeMultiset.isAVLBalanced()).toBe(true);
84
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
85
85
 
86
- expect(treeMultiset.getHeight(15)).toBe(1);
86
+ expect(treeMultimap.getHeight(15)).toBe(1);
87
87
 
88
- const removed1 = treeMultiset.delete(1, undefined, true);
88
+ const removed1 = treeMultimap.delete(1, undefined, true);
89
89
  expect(removed1 instanceof Array);
90
90
  expect(removed1[0]);
91
91
  expect(removed1[0].deleted);
92
92
  if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
93
93
 
94
- expect(treeMultiset.isAVLBalanced()).toBe(true);
94
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
95
95
 
96
- expect(treeMultiset.getHeight()).toBe(4);
96
+ expect(treeMultimap.getHeight()).toBe(4);
97
97
 
98
- const removed4 = treeMultiset.delete(4, undefined, true);
98
+ const removed4 = treeMultimap.delete(4, undefined, true);
99
99
  expect(removed4 instanceof Array);
100
100
  expect(removed4[0]);
101
101
  expect(removed4[0].deleted);
102
102
  if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
103
103
 
104
- expect(treeMultiset.isAVLBalanced()).toBe(true);
105
- expect(treeMultiset.getHeight()).toBe(4);
104
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
105
+ expect(treeMultimap.getHeight()).toBe(4);
106
106
 
107
- const removed10 = treeMultiset.delete(10, undefined, true);
107
+ const removed10 = treeMultimap.delete(10, undefined, true);
108
108
  expect(removed10 instanceof Array);
109
109
  expect(removed10[0]);
110
110
  expect(removed10[0].deleted);
111
111
  if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
112
- expect(treeMultiset.isAVLBalanced()).toBe(true);
112
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
113
113
 
114
- expect(treeMultiset.getHeight()).toBe(3);
114
+ expect(treeMultimap.getHeight()).toBe(3);
115
115
 
116
- const removed15 = treeMultiset.delete(15, undefined, true);
116
+ const removed15 = treeMultimap.delete(15, undefined, true);
117
117
  expect(removed15 instanceof Array);
118
118
  expect(removed15[0]);
119
119
  expect(removed15[0].deleted);
120
120
  if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
121
121
 
122
- expect(treeMultiset.isAVLBalanced()).toBe(true);
123
- expect(treeMultiset.getHeight()).toBe(3);
122
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
123
+ expect(treeMultimap.getHeight()).toBe(3);
124
124
 
125
- const removed5 = treeMultiset.delete(5, undefined, true);
125
+ const removed5 = treeMultimap.delete(5, undefined, true);
126
126
  expect(removed5 instanceof Array);
127
127
  expect(removed5[0]);
128
128
  expect(removed5[0].deleted);
129
129
  if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
130
130
 
131
- expect(treeMultiset.isAVLBalanced()).toBe(true);
132
- expect(treeMultiset.getHeight()).toBe(3);
131
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
132
+ expect(treeMultimap.getHeight()).toBe(3);
133
133
 
134
- const removed13 = treeMultiset.delete(13, undefined, true);
134
+ const removed13 = treeMultimap.delete(13, undefined, true);
135
135
  expect(removed13 instanceof Array);
136
136
  expect(removed13[0]);
137
137
  expect(removed13[0].deleted);
138
138
  if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
139
- expect(treeMultiset.isAVLBalanced()).toBe(true);
140
- expect(treeMultiset.getHeight()).toBe(3);
139
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
140
+ expect(treeMultimap.getHeight()).toBe(3);
141
141
 
142
- const removed3 = treeMultiset.delete(3, undefined, true);
142
+ const removed3 = treeMultimap.delete(3, undefined, true);
143
143
  expect(removed3 instanceof Array);
144
144
  expect(removed3[0]);
145
145
  expect(removed3[0].deleted);
146
146
  if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
147
- expect(treeMultiset.isAVLBalanced()).toBe(true);
148
- expect(treeMultiset.getHeight()).toBe(3);
147
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
148
+ expect(treeMultimap.getHeight()).toBe(3);
149
149
 
150
- const removed8 = treeMultiset.delete(8, undefined, true);
150
+ const removed8 = treeMultimap.delete(8, undefined, true);
151
151
  expect(removed8 instanceof Array);
152
152
  expect(removed8[0]);
153
153
  expect(removed8[0].deleted);
154
154
  if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
155
- expect(treeMultiset.isAVLBalanced()).toBe(true);
156
- expect(treeMultiset.getHeight()).toBe(3);
155
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
156
+ expect(treeMultimap.getHeight()).toBe(3);
157
157
 
158
- const removed6 = treeMultiset.delete(6, undefined, true);
158
+ const removed6 = treeMultimap.delete(6, undefined, true);
159
159
  expect(removed6 instanceof Array);
160
160
  expect(removed6[0]);
161
161
  expect(removed6[0].deleted);
162
162
  if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
163
- expect(treeMultiset.delete(6, undefined, true).length).toBe(0);
164
- expect(treeMultiset.isAVLBalanced()).toBe(true);
163
+ expect(treeMultimap.delete(6, undefined, true).length).toBe(0);
164
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
165
165
 
166
- expect(treeMultiset.getHeight()).toBe(2);
166
+ expect(treeMultimap.getHeight()).toBe(2);
167
167
 
168
- const removed7 = treeMultiset.delete(7, undefined, true);
168
+ const removed7 = treeMultimap.delete(7, undefined, true);
169
169
  expect(removed7 instanceof Array);
170
170
  expect(removed7[0]);
171
171
  expect(removed7[0].deleted);
172
172
  if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
173
- expect(treeMultiset.isAVLBalanced()).toBe(true);
174
- expect(treeMultiset.getHeight()).toBe(2);
173
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
174
+ expect(treeMultimap.getHeight()).toBe(2);
175
175
 
176
- const removed9 = treeMultiset.delete(9, undefined, true);
176
+ const removed9 = treeMultimap.delete(9, undefined, true);
177
177
  expect(removed9 instanceof Array);
178
178
  expect(removed9[0]);
179
179
  expect(removed9[0].deleted);
180
180
  if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
181
- expect(treeMultiset.isAVLBalanced()).toBe(true);
182
- expect(treeMultiset.getHeight()).toBe(2);
181
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
182
+ expect(treeMultimap.getHeight()).toBe(2);
183
183
 
184
- const removed14 = treeMultiset.delete(14, undefined, true);
184
+ const removed14 = treeMultimap.delete(14, undefined, true);
185
185
  expect(removed14 instanceof Array);
186
186
  expect(removed14[0]);
187
187
  expect(removed14[0].deleted);
188
188
  if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
189
- expect(treeMultiset.isAVLBalanced()).toBe(true);
190
- expect(treeMultiset.getHeight()).toBe(1);
189
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
190
+ expect(treeMultimap.getHeight()).toBe(1);
191
191
 
192
- expect(treeMultiset.isAVLBalanced()).toBe(true);
192
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
193
193
 
194
- const bfsIDs = treeMultiset.bfs(node => node.key);
194
+ const bfsIDs = treeMultimap.bfs(node => node.key);
195
195
 
196
196
  expect(bfsIDs[0]).toBe(12);
197
197
  expect(bfsIDs[1]).toBe(2);
198
198
  expect(bfsIDs[2]).toBe(16);
199
199
 
200
- const bfsNodes = treeMultiset.bfs(node => node);
200
+ const bfsNodes = treeMultimap.bfs(node => node);
201
201
 
202
202
  expect(bfsNodes[0].key).toBe(12);
203
203
  expect(bfsNodes[1].key).toBe(2);
204
204
  expect(bfsNodes[2].key).toBe(16);
205
205
 
206
- expect(treeMultiset.count).toBe(9);
206
+ expect(treeMultimap.count).toBe(9);
207
207
  });
208
208
 
209
209
  it('should perform various operations on a Binary Search Tree with object values', () => {
210
- const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
211
- expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
212
- objTreeMultiset.add(11, {key: 11, keyA: 11});
213
- objTreeMultiset.add(3, {key: 3, keyA: 3});
210
+ const objTreeMultimap = new TreeMultimap<{key: number; keyA: number}>();
211
+ expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
212
+ objTreeMultimap.add(11, {key: 11, keyA: 11});
213
+ objTreeMultimap.add(3, {key: 3, keyA: 3});
214
214
  const values = [
215
215
  {key: 15, keyA: 15},
216
216
  {key: 1, keyA: 1},
@@ -228,229 +228,229 @@ describe('TreeMultiset operations test', () => {
228
228
  {key: 5, keyA: 5}
229
229
  ];
230
230
 
231
- objTreeMultiset.addMany(
231
+ objTreeMultimap.addMany(
232
232
  values.map(item => item.key),
233
233
  values
234
234
  );
235
235
 
236
- expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode);
236
+ expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
237
237
 
238
- if (objTreeMultiset.root) expect(objTreeMultiset.root.key).toBe(11);
238
+ if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11);
239
239
 
240
- expect(objTreeMultiset.count).toBe(16);
240
+ expect(objTreeMultimap.count).toBe(16);
241
241
 
242
- expect(objTreeMultiset.has(6)).toBe(true);
242
+ expect(objTreeMultimap.has(6)).toBe(true);
243
243
  });
244
244
  });
245
245
 
246
- describe('TreeMultiset operations test recursively', () => {
246
+ describe('TreeMultimap operations test recursively', () => {
247
247
  it('should perform various operations on a Binary Search Tree with numeric values', () => {
248
- const treeMultiset = new TreeMultiset({iterationType: IterationType.RECURSIVE});
248
+ const treeMultimap = new TreeMultimap({iterationType: IterationType.RECURSIVE});
249
249
 
250
- expect(treeMultiset instanceof TreeMultiset);
251
- treeMultiset.add(11, 11);
252
- treeMultiset.add(3, 3);
250
+ expect(treeMultimap instanceof TreeMultimap);
251
+ treeMultimap.add(11, 11);
252
+ treeMultimap.add(3, 3);
253
253
  const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
254
- treeMultiset.addMany(idAndValues, idAndValues);
255
- expect(treeMultiset.root instanceof TreeMultisetNode);
254
+ treeMultimap.addMany(idAndValues, idAndValues);
255
+ expect(treeMultimap.root instanceof TreeMultimapNode);
256
256
 
257
- if (treeMultiset.root) expect(treeMultiset.root.key == 11);
257
+ if (treeMultimap.root) expect(treeMultimap.root.key == 11);
258
258
 
259
- expect(treeMultiset.size).toBe(16);
260
- expect(treeMultiset.count).toBe(18);
259
+ expect(treeMultimap.size).toBe(16);
260
+ expect(treeMultimap.count).toBe(18);
261
261
 
262
- expect(treeMultiset.has(6));
262
+ expect(treeMultimap.has(6));
263
263
 
264
- expect(treeMultiset.getHeight(6)).toBe(3);
265
- expect(treeMultiset.getDepth(6)).toBe(1);
266
- const nodeId10 = treeMultiset.getNode(10);
264
+ expect(treeMultimap.getHeight(6)).toBe(3);
265
+ expect(treeMultimap.getDepth(6)).toBe(1);
266
+ const nodeId10 = treeMultimap.getNode(10);
267
267
  expect(nodeId10?.key).toBe(10);
268
268
 
269
- const nodeVal9 = treeMultiset.getNode(9, node => node.value);
269
+ const nodeVal9 = treeMultimap.getNode(9, node => node.value);
270
270
  expect(nodeVal9?.key).toBe(9);
271
271
 
272
- const nodesByCount1 = treeMultiset.getNodes(1, node => node.count);
272
+ const nodesByCount1 = treeMultimap.getNodes(1, node => node.count);
273
273
  expect(nodesByCount1.length).toBe(14);
274
274
 
275
- const nodesByCount2 = treeMultiset.getNodes(2, node => node.count);
275
+ const nodesByCount2 = treeMultimap.getNodes(2, node => node.count);
276
276
  expect(nodesByCount2.length).toBe(2);
277
- const leftMost = treeMultiset.getLeftMost();
277
+ const leftMost = treeMultimap.getLeftMost();
278
278
  expect(leftMost?.key).toBe(1);
279
279
 
280
- const node15 = treeMultiset.getNode(15);
281
- const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
280
+ const node15 = treeMultimap.getNode(15);
281
+ const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
282
282
  expect(minNodeBySpecificNode?.key).toBe(12);
283
283
 
284
284
  let subTreeSum = 0;
285
- node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (subTreeSum += node.key), 15);
285
+ node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
286
286
  expect(subTreeSum).toBe(70);
287
287
  let lesserSum = 0;
288
- treeMultiset.lesserOrGreaterTraverse((node: TreeMultisetNode<number>) => (lesserSum += node.key), CP.lt, 10);
288
+ treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
289
289
  expect(lesserSum).toBe(45);
290
290
 
291
- expect(node15 instanceof TreeMultisetNode);
292
- if (node15 instanceof TreeMultisetNode) {
293
- const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (node.count += 1), 15);
291
+ expect(node15 instanceof TreeMultimapNode);
292
+ if (node15 instanceof TreeMultimapNode) {
293
+ const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (node.count += 1), 15);
294
294
  expect(subTreeAdd);
295
295
  }
296
- const node11 = treeMultiset.getNode(11);
297
- expect(node11 instanceof TreeMultisetNode);
298
- if (node11 instanceof TreeMultisetNode) {
299
- const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
296
+ const node11 = treeMultimap.getNode(11);
297
+ expect(node11 instanceof TreeMultimapNode);
298
+ if (node11 instanceof TreeMultimapNode) {
299
+ const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
300
300
  expect(allGreaterNodesAdded);
301
301
  }
302
302
 
303
- const dfsInorderNodes = treeMultiset.dfs(node => node, 'in');
303
+ const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
304
304
  expect(dfsInorderNodes[0].key).toBe(1);
305
305
  expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
306
- expect(treeMultiset.isPerfectlyBalanced()).toBe(false);
306
+ expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
307
307
 
308
- treeMultiset.perfectlyBalance();
308
+ treeMultimap.perfectlyBalance();
309
309
 
310
- expect(treeMultiset.isPerfectlyBalanced()).toBe(true);
311
- expect(treeMultiset.isAVLBalanced()).toBe(true);
310
+ expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
311
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
312
312
 
313
- const bfsNodesAfterBalanced = treeMultiset.bfs(node => node);
313
+ const bfsNodesAfterBalanced = treeMultimap.bfs(node => node);
314
314
  expect(bfsNodesAfterBalanced[0].key).toBe(8);
315
315
  expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
316
316
 
317
- const removed11 = treeMultiset.delete(11, undefined, true);
317
+ const removed11 = treeMultimap.delete(11, undefined, true);
318
318
  expect(removed11 instanceof Array);
319
319
  expect(removed11[0]);
320
320
  expect(removed11[0].deleted);
321
321
 
322
322
  if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
323
323
 
324
- expect(treeMultiset.isAVLBalanced()).toBe(true);
324
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
325
325
 
326
- expect(treeMultiset.getHeight(15)).toBe(1);
326
+ expect(treeMultimap.getHeight(15)).toBe(1);
327
327
 
328
- const removed1 = treeMultiset.delete(1, undefined, true);
328
+ const removed1 = treeMultimap.delete(1, undefined, true);
329
329
  expect(removed1 instanceof Array);
330
330
  expect(removed1[0]);
331
331
  expect(removed1[0].deleted);
332
332
  if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
333
333
 
334
- expect(treeMultiset.isAVLBalanced()).toBe(true);
334
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
335
335
 
336
- expect(treeMultiset.getHeight()).toBe(4);
336
+ expect(treeMultimap.getHeight()).toBe(4);
337
337
 
338
- const removed4 = treeMultiset.delete(4, undefined, true);
338
+ const removed4 = treeMultimap.delete(4, undefined, true);
339
339
  expect(removed4 instanceof Array);
340
340
  expect(removed4[0]);
341
341
  expect(removed4[0].deleted);
342
342
  if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
343
343
 
344
- expect(treeMultiset.isAVLBalanced()).toBe(true);
345
- expect(treeMultiset.getHeight()).toBe(4);
344
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
345
+ expect(treeMultimap.getHeight()).toBe(4);
346
346
 
347
- const removed10 = treeMultiset.delete(10, undefined, true);
347
+ const removed10 = treeMultimap.delete(10, undefined, true);
348
348
  expect(removed10 instanceof Array);
349
349
  expect(removed10[0]);
350
350
  expect(removed10[0].deleted);
351
351
  if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
352
- expect(treeMultiset.isAVLBalanced()).toBe(true);
352
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
353
353
 
354
- expect(treeMultiset.getHeight()).toBe(3);
354
+ expect(treeMultimap.getHeight()).toBe(3);
355
355
 
356
- const removed15 = treeMultiset.delete(15, undefined, true);
356
+ const removed15 = treeMultimap.delete(15, undefined, true);
357
357
  expect(removed15 instanceof Array);
358
358
  expect(removed15[0]);
359
359
  expect(removed15[0].deleted);
360
360
  if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
361
361
 
362
- expect(treeMultiset.isAVLBalanced()).toBe(true);
363
- expect(treeMultiset.getHeight()).toBe(3);
362
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
363
+ expect(treeMultimap.getHeight()).toBe(3);
364
364
 
365
- const removed5 = treeMultiset.delete(5, undefined, true);
365
+ const removed5 = treeMultimap.delete(5, undefined, true);
366
366
  expect(removed5 instanceof Array);
367
367
  expect(removed5[0]);
368
368
  expect(removed5[0].deleted);
369
369
  if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
370
370
 
371
- expect(treeMultiset.isAVLBalanced()).toBe(true);
372
- expect(treeMultiset.getHeight()).toBe(3);
371
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
372
+ expect(treeMultimap.getHeight()).toBe(3);
373
373
 
374
- const removed13 = treeMultiset.delete(13, undefined, true);
374
+ const removed13 = treeMultimap.delete(13, undefined, true);
375
375
  expect(removed13 instanceof Array);
376
376
  expect(removed13[0]);
377
377
  expect(removed13[0].deleted);
378
378
  if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
379
- expect(treeMultiset.isAVLBalanced()).toBe(true);
380
- expect(treeMultiset.getHeight()).toBe(3);
379
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
380
+ expect(treeMultimap.getHeight()).toBe(3);
381
381
 
382
- const removed3 = treeMultiset.delete(3, undefined, true);
382
+ const removed3 = treeMultimap.delete(3, undefined, true);
383
383
  expect(removed3 instanceof Array);
384
384
  expect(removed3[0]);
385
385
  expect(removed3[0].deleted);
386
386
  if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
387
- expect(treeMultiset.isAVLBalanced()).toBe(true);
388
- expect(treeMultiset.getHeight()).toBe(3);
387
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
388
+ expect(treeMultimap.getHeight()).toBe(3);
389
389
 
390
- const removed8 = treeMultiset.delete(8, undefined, true);
390
+ const removed8 = treeMultimap.delete(8, undefined, true);
391
391
  expect(removed8 instanceof Array);
392
392
  expect(removed8[0]);
393
393
  expect(removed8[0].deleted);
394
394
  if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
395
- expect(treeMultiset.isAVLBalanced()).toBe(true);
396
- expect(treeMultiset.getHeight()).toBe(3);
395
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
396
+ expect(treeMultimap.getHeight()).toBe(3);
397
397
 
398
- const removed6 = treeMultiset.delete(6, undefined, true);
398
+ const removed6 = treeMultimap.delete(6, undefined, true);
399
399
  expect(removed6 instanceof Array);
400
400
  expect(removed6[0]);
401
401
  expect(removed6[0].deleted);
402
402
  if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
403
- expect(treeMultiset.delete(6, undefined, true).length).toBe(0);
404
- expect(treeMultiset.isAVLBalanced()).toBe(true);
403
+ expect(treeMultimap.delete(6, undefined, true).length).toBe(0);
404
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
405
405
 
406
- expect(treeMultiset.getHeight()).toBe(2);
406
+ expect(treeMultimap.getHeight()).toBe(2);
407
407
 
408
- const removed7 = treeMultiset.delete(7, undefined, true);
408
+ const removed7 = treeMultimap.delete(7, undefined, true);
409
409
  expect(removed7 instanceof Array);
410
410
  expect(removed7[0]);
411
411
  expect(removed7[0].deleted);
412
412
  if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
413
- expect(treeMultiset.isAVLBalanced()).toBe(true);
414
- expect(treeMultiset.getHeight()).toBe(2);
413
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
414
+ expect(treeMultimap.getHeight()).toBe(2);
415
415
 
416
- const removed9 = treeMultiset.delete(9, undefined, true);
416
+ const removed9 = treeMultimap.delete(9, undefined, true);
417
417
  expect(removed9 instanceof Array);
418
418
  expect(removed9[0]);
419
419
  expect(removed9[0].deleted);
420
420
  if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
421
- expect(treeMultiset.isAVLBalanced()).toBe(true);
422
- expect(treeMultiset.getHeight()).toBe(2);
421
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
422
+ expect(treeMultimap.getHeight()).toBe(2);
423
423
 
424
- const removed14 = treeMultiset.delete(14, undefined, true);
424
+ const removed14 = treeMultimap.delete(14, undefined, true);
425
425
  expect(removed14 instanceof Array);
426
426
  expect(removed14[0]);
427
427
  expect(removed14[0].deleted);
428
428
  if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
429
- expect(treeMultiset.isAVLBalanced()).toBe(true);
430
- expect(treeMultiset.getHeight()).toBe(1);
429
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
430
+ expect(treeMultimap.getHeight()).toBe(1);
431
431
 
432
- expect(treeMultiset.isAVLBalanced()).toBe(true);
432
+ expect(treeMultimap.isAVLBalanced()).toBe(true);
433
433
 
434
- const bfsIDs = treeMultiset.bfs(node => node.key);
434
+ const bfsIDs = treeMultimap.bfs(node => node.key);
435
435
 
436
436
  expect(bfsIDs[0]).toBe(12);
437
437
  expect(bfsIDs[1]).toBe(2);
438
438
  expect(bfsIDs[2]).toBe(16);
439
439
 
440
- const bfsNodes = treeMultiset.bfs(node => node);
440
+ const bfsNodes = treeMultimap.bfs(node => node);
441
441
 
442
442
  expect(bfsNodes[0].key).toBe(12);
443
443
  expect(bfsNodes[1].key).toBe(2);
444
444
  expect(bfsNodes[2].key).toBe(16);
445
445
 
446
- expect(treeMultiset.count).toBe(9);
446
+ expect(treeMultimap.count).toBe(9);
447
447
  });
448
448
 
449
449
  it('should perform various operations on a Binary Search Tree with object values', () => {
450
- const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
451
- expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
452
- objTreeMultiset.add(11, {key: 11, keyA: 11});
453
- objTreeMultiset.add(3, {key: 3, keyA: 3});
450
+ const objTreeMultimap = new TreeMultimap<{key: number; keyA: number}>();
451
+ expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
452
+ objTreeMultimap.add(11, {key: 11, keyA: 11});
453
+ objTreeMultimap.add(3, {key: 3, keyA: 3});
454
454
  const values = [
455
455
  {key: 15, keyA: 15},
456
456
  {key: 1, keyA: 1},
@@ -468,29 +468,29 @@ describe('TreeMultiset operations test recursively', () => {
468
468
  {key: 5, keyA: 5}
469
469
  ];
470
470
 
471
- objTreeMultiset.addMany(
471
+ objTreeMultimap.addMany(
472
472
  values.map(item => item.key),
473
473
  values
474
474
  );
475
475
 
476
- expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode);
476
+ expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
477
477
 
478
- if (objTreeMultiset.root) expect(objTreeMultiset.root.key).toBe(11);
478
+ if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11);
479
479
 
480
- expect(objTreeMultiset.count).toBe(16);
480
+ expect(objTreeMultimap.count).toBe(16);
481
481
 
482
- expect(objTreeMultiset.has(6)).toBe(true);
482
+ expect(objTreeMultimap.has(6)).toBe(true);
483
483
  });
484
484
  });
485
485
 
486
- describe('TreeMultiset Performance test', function () {
487
- const treeMS = new TreeMultiset<TreeMultisetNode<number>>();
486
+ describe('TreeMultimap Performance test', function () {
487
+ const treeMS = new TreeMultimap<TreeMultimapNode<number>>();
488
488
  const inputSize = 100000; // Adjust input sizes as needed
489
489
 
490
490
  beforeEach(() => {
491
491
  treeMS.clear();
492
492
  });
493
- it(`Observe the time consumption of TreeMultiset.add fitting O(n log n)`, function () {
493
+ it(`Observe the time consumption of TreeMultimap.add fitting O(n log n)`, function () {
494
494
  // // Create a benchmark suite
495
495
  // const suite = new Benchmark.Suite();
496
496
  // // Define a function to generate a random array of a given size
@@ -503,7 +503,7 @@ describe('TreeMultiset Performance test', function () {
503
503
  // }
504
504
  // const inputArray = generateRandomArray(inputSize[0]);
505
505
  //
506
- // suite.add(`TreeMultiset addMany (n=${inputSize[0]})`, () => {
506
+ // suite.add(`TreeMultimap addMany (n=${inputSize[0]})`, () => {
507
507
  // treeMS.addMany([...inputArray]);
508
508
  // });
509
509
  //
@@ -523,7 +523,7 @@ describe('TreeMultiset Performance test', function () {
523
523
  // .run({async: true});
524
524
  });
525
525
 
526
- it(`Observe the time consumption of TreeMultiset.dfs be good`, function () {
526
+ it(`Observe the time consumption of TreeMultimap.dfs be good`, function () {
527
527
  const startDFS = performance.now();
528
528
  const dfs = treeMS.dfs(node => node);
529
529
  isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);