data-structure-typed 1.50.5 → 1.50.6

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 (28) hide show
  1. package/CHANGELOG.md +1 -1
  2. package/README.md +13 -13
  3. package/benchmark/report.html +13 -13
  4. package/benchmark/report.json +168 -144
  5. package/dist/cjs/data-structures/binary-tree/binary-tree.js +19 -19
  6. package/dist/cjs/data-structures/binary-tree/binary-tree.js.map +1 -1
  7. package/dist/cjs/data-structures/binary-tree/rb-tree.d.ts +158 -135
  8. package/dist/cjs/data-structures/binary-tree/rb-tree.js +415 -386
  9. package/dist/cjs/data-structures/binary-tree/rb-tree.js.map +1 -1
  10. package/dist/cjs/data-structures/binary-tree/tree-multi-map.d.ts +1 -0
  11. package/dist/cjs/data-structures/binary-tree/tree-multi-map.js +84 -76
  12. package/dist/cjs/data-structures/binary-tree/tree-multi-map.js.map +1 -1
  13. package/dist/mjs/data-structures/binary-tree/binary-tree.js +19 -19
  14. package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts +158 -135
  15. package/dist/mjs/data-structures/binary-tree/rb-tree.js +412 -386
  16. package/dist/mjs/data-structures/binary-tree/tree-multi-map.d.ts +1 -0
  17. package/dist/mjs/data-structures/binary-tree/tree-multi-map.js +84 -76
  18. package/dist/umd/data-structure-typed.js +477 -431
  19. package/dist/umd/data-structure-typed.min.js +2 -2
  20. package/dist/umd/data-structure-typed.min.js.map +1 -1
  21. package/package.json +1 -1
  22. package/src/data-structures/binary-tree/binary-tree.ts +19 -19
  23. package/src/data-structures/binary-tree/rb-tree.ts +437 -395
  24. package/src/data-structures/binary-tree/tree-multi-map.ts +85 -82
  25. package/test/performance/data-structures/binary-tree/rb-tree.test.ts +26 -16
  26. package/test/unit/data-structures/binary-tree/overall.test.ts +23 -21
  27. package/test/unit/data-structures/binary-tree/rb-tree.test.ts +168 -105
  28. package/test/unit/data-structures/binary-tree/tree-multi-map.test.ts +311 -192
package/test/unit/data-structures/binary-tree/tree-multi-map.test.ts CHANGED
@@ -8,6 +8,7 @@ import {
8
8
  TreeMultiMapNode
9
9
  } from '../../../../src';
10
10
  import { isDebugTest } from '../../../config';
11
+ import { getRandomInt } from '../../../utils';
11
12
 
12
13
  const isDebug = isDebugTest;
13
14
  // const isDebug = true;
@@ -28,6 +29,8 @@ describe('TreeMultiMap count', () => {
28
29
  const newNode = new TreeMultiMapNode(3, 33, 10);
29
30
  tm.add(newNode);
30
31
  expect(tm.count).toBe(15);
32
+ expect(tm.getMutableCount()).toBe(15);
33
+ expect(tm.getNode(3)?.count).toBe(11);
31
34
  });
32
35
 
33
36
  it('Should count', () => {
@@ -37,17 +40,61 @@ describe('TreeMultiMap count', () => {
37
40
  [3, 3]
38
41
  ]);
39
42
  tm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 1);
40
- expect(tm.count).toBe(7);
43
+ expect(tm.getMutableCount()).toBe(7);
44
+ expect(tm.count).toBe(3);
41
45
  });
42
46
  });
43
47
 
44
48
  describe('TreeMultiMap operations test1', () => {
49
+ it('should size and count', () => {
50
+ const treeMultiMap = new TreeMultiMap();
51
+
52
+ expect(treeMultiMap instanceof TreeMultiMap);
53
+
54
+ treeMultiMap.add([11, 11]);
55
+ treeMultiMap.add([3, 3]);
56
+ expect(treeMultiMap.count).toBe(2);
57
+ expect(treeMultiMap.getMutableCount()).toBe(2);
58
+ expect(treeMultiMap.size).toBe(2);
59
+
60
+ const keyValuePairs: [number, number][] = [
61
+ [11, 11],
62
+ [3, 3],
63
+ [15, 15],
64
+ [1, 1],
65
+ [8, 8],
66
+ [13, 13],
67
+ [16, 16],
68
+ [2, 2],
69
+ [6, 6],
70
+ [9, 9],
71
+ [12, 12],
72
+ [14, 14],
73
+ [4, 4],
74
+ [7, 7],
75
+ [10, 10],
76
+ [5, 5]
77
+ ];
78
+
79
+ treeMultiMap.addMany(keyValuePairs);
80
+ expect(treeMultiMap.size).toBe(16);
81
+ expect(treeMultiMap.count).toBe(18);
82
+ expect(treeMultiMap.getMutableCount()).toBe(18);
83
+ treeMultiMap.delete(11);
84
+ expect(treeMultiMap.count).toBe(17);
85
+ expect(treeMultiMap.getMutableCount()).toBe(17);
86
+ treeMultiMap.delete(3, undefined, true);
87
+ expect(treeMultiMap.count).toBe(15);
88
+ expect(treeMultiMap.getMutableCount()).toBe(15);
89
+ });
90
+
45
91
  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
46
- const treeMultimap = new TreeMultiMap();
92
+ const treeMultiMap = new TreeMultiMap();
93
+
94
+ expect(treeMultiMap instanceof TreeMultiMap);
47
95
 
48
- expect(treeMultimap instanceof TreeMultiMap);
49
- treeMultimap.add([11, 11]);
50
- treeMultimap.add([3, 3]);
96
+ treeMultiMap.add([11, 11]);
97
+ treeMultiMap.add([3, 3]);
51
98
  const idAndValues: [number, number][] = [
52
99
  [11, 11],
53
100
  [3, 3],
@@ -66,199 +113,201 @@ describe('TreeMultiMap operations test1', () => {
66
113
  [10, 10],
67
114
  [5, 5]
68
115
  ];
69
- treeMultimap.addMany(idAndValues);
70
- expect(treeMultimap.root instanceof TreeMultiMapNode);
71
-
72
- if (treeMultimap.root) expect(treeMultimap.root.key == 11);
116
+ treeMultiMap.addMany(idAndValues);
117
+ expect(treeMultiMap.root instanceof TreeMultiMapNode);
73
118
 
74
- expect(treeMultimap.size).toBe(16);
75
- expect(treeMultimap.count).toBe(18);
119
+ if (treeMultiMap.root) expect(treeMultiMap.root.key == 11);
76
120
 
77
- expect(treeMultimap.has(6));
121
+ expect(treeMultiMap.size).toBe(16);
122
+ expect(treeMultiMap.count).toBe(18);
123
+ expect(treeMultiMap.getMutableCount()).toBe(18);
78
124
 
79
- expect(treeMultimap.getHeight(6)).toBe(2);
80
- expect(treeMultimap.getDepth(6)).toBe(4);
81
- const nodeId10 = treeMultimap.getNode(10);
125
+ expect(treeMultiMap.has(6));
126
+ isDebug && treeMultiMap.print();
127
+ expect(treeMultiMap.getHeight(6)).toBe(1);
128
+ expect(treeMultiMap.getDepth(6)).toBe(3);
129
+ const nodeId10 = treeMultiMap.getNode(10);
82
130
  expect(nodeId10?.key).toBe(10);
83
131
 
84
- const nodeVal9 = treeMultimap.getNode(9, node => node.value);
132
+ const nodeVal9 = treeMultiMap.getNode(9, node => node.value);
85
133
  expect(nodeVal9?.key).toBe(9);
86
134
 
87
- const nodesByCount1 = treeMultimap.getNodes(1, node => node.count);
135
+ const nodesByCount1 = treeMultiMap.getNodes(1, node => node.count);
88
136
  expect(nodesByCount1.length).toBe(14);
89
137
 
90
- const nodesByCount2 = treeMultimap.getNodes(2, node => node.count);
138
+ const nodesByCount2 = treeMultiMap.getNodes(2, node => node.count);
91
139
  expect(nodesByCount2.length).toBe(2);
92
- const leftMost = treeMultimap.getLeftMost();
140
+ const leftMost = treeMultiMap.getLeftMost();
93
141
  expect(leftMost?.key).toBe(1);
94
142
 
95
- const node15 = treeMultimap.getNode(15);
96
- const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
97
- expect(minNodeBySpecificNode?.key).toBe(15);
143
+ const node15 = treeMultiMap.getNode(15);
144
+ const minNodeBySpecificNode = node15 && treeMultiMap.getLeftMost(node15);
145
+ expect(minNodeBySpecificNode?.key).toBe(14);
98
146
 
99
147
  let subTreeSum = 0;
100
- node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
101
- expect(subTreeSum).toBe(31);
148
+ node15 && treeMultiMap.dfs(node => (subTreeSum += node.key), 'pre', 15);
149
+ expect(subTreeSum).toBe(45);
102
150
  let lesserSum = 0;
103
- treeMultimap.lesserOrGreaterTraverse((node: TreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
151
+ treeMultiMap.lesserOrGreaterTraverse((node: TreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
104
152
  expect(lesserSum).toBe(45);
105
153
 
106
154
  expect(node15 instanceof TreeMultiMapNode);
107
155
  if (node15 instanceof TreeMultiMapNode) {
108
- const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
156
+ const subTreeAdd = treeMultiMap.dfs(node => (node.count += 1), 'pre', 15);
109
157
  expect(subTreeAdd);
110
158
  }
111
- const node11 = treeMultimap.getNode(11);
159
+ const node11 = treeMultiMap.getNode(11);
112
160
  expect(node11 instanceof TreeMultiMapNode);
113
161
  if (node11 instanceof TreeMultiMapNode) {
114
- const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
162
+ const allGreaterNodesAdded = treeMultiMap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
115
163
  expect(allGreaterNodesAdded);
116
164
  }
117
165
 
118
- const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
166
+ const dfsInorderNodes = treeMultiMap.dfs(node => node, 'in');
119
167
  expect(dfsInorderNodes[0].key).toBe(1);
120
168
  expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
121
- expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
122
169
 
123
- treeMultimap.perfectlyBalance();
170
+ expect(treeMultiMap.isPerfectlyBalanced()).toBe(true);
171
+ treeMultiMap.perfectlyBalance();
172
+ expect(treeMultiMap.isPerfectlyBalanced()).toBe(false);
124
173
 
125
- expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
126
- expect(treeMultimap.isAVLBalanced()).toBe(true);
174
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
127
175
 
128
- const bfsNodesAfterBalanced = treeMultimap.bfs(node => node);
129
- expect(bfsNodesAfterBalanced[0].key).toBe(8);
176
+ const bfsNodesAfterBalanced = treeMultiMap.bfs(node => node);
177
+ expect(bfsNodesAfterBalanced[0].key).toBe(6);
130
178
  expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
131
179
 
132
- const removed11 = treeMultimap.delete(11, undefined, true);
180
+ const removed11 = treeMultiMap.delete(11, undefined, true);
133
181
  expect(removed11 instanceof Array);
134
182
  expect(removed11[0]);
135
183
  expect(removed11[0].deleted);
136
184
 
137
185
  if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
138
186
 
139
- expect(treeMultimap.isAVLBalanced()).toBe(true);
187
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
140
188
 
141
- expect(treeMultimap.getHeight(15)).toBe(2);
189
+ expect(treeMultiMap.getHeight(15)).toBe(1);
142
190
 
143
- const removed1 = treeMultimap.delete(1, undefined, true);
191
+ const removed1 = treeMultiMap.delete(1, undefined, true);
144
192
  expect(removed1 instanceof Array);
145
193
  expect(removed1[0]);
146
194
  expect(removed1[0].deleted);
147
195
  if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
148
196
 
149
- expect(treeMultimap.isAVLBalanced()).toBe(true);
197
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
150
198
 
151
- expect(treeMultimap.getHeight()).toBe(5);
199
+ expect(treeMultiMap.getHeight()).toBe(5);
152
200
 
153
- const removed4 = treeMultimap.delete(4, undefined, true);
201
+ const removed4 = treeMultiMap.delete(4, undefined, true);
154
202
  expect(removed4 instanceof Array);
155
203
  expect(removed4[0]);
156
204
  expect(removed4[0].deleted);
157
205
  if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
158
206
 
159
- expect(treeMultimap.isAVLBalanced()).toBe(true);
160
- expect(treeMultimap.getHeight()).toBe(5);
207
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
208
+ expect(treeMultiMap.getHeight()).toBe(5);
161
209
 
162
- const removed10 = treeMultimap.delete(10, undefined, true);
210
+ const removed10 = treeMultiMap.delete(10, undefined, true);
163
211
  expect(removed10 instanceof Array);
164
212
  expect(removed10[0]);
165
213
  expect(removed10[0].deleted);
166
214
  if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
167
- expect(treeMultimap.isAVLBalanced()).toBe(false);
215
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
168
216
 
169
- expect(treeMultimap.getHeight()).toBe(5);
217
+ expect(treeMultiMap.getHeight()).toBe(4);
170
218
 
171
- const removed15 = treeMultimap.delete(15, undefined, true);
219
+ const removed15 = treeMultiMap.delete(15, undefined, true);
172
220
  expect(removed15 instanceof Array);
173
221
  expect(removed15[0]);
174
222
  expect(removed15[0].deleted);
175
223
  if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
176
224
 
177
- expect(treeMultimap.isAVLBalanced()).toBe(true);
178
- expect(treeMultimap.getHeight()).toBe(4);
225
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
226
+ expect(treeMultiMap.getHeight()).toBe(3);
179
227
 
180
- const removed5 = treeMultimap.delete(5, undefined, true);
228
+ const removed5 = treeMultiMap.delete(5, undefined, true);
181
229
  expect(removed5 instanceof Array);
182
230
  expect(removed5[0]);
183
231
  expect(removed5[0].deleted);
184
232
  if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
185
233
 
186
- expect(treeMultimap.isAVLBalanced()).toBe(true);
187
- expect(treeMultimap.getHeight()).toBe(4);
234
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
235
+ expect(treeMultiMap.getHeight()).toBe(3);
188
236
 
189
- const removed13 = treeMultimap.delete(13, undefined, true);
237
+ const removed13 = treeMultiMap.delete(13, undefined, true);
190
238
  expect(removed13 instanceof Array);
191
239
  expect(removed13[0]);
192
240
  expect(removed13[0].deleted);
193
241
  if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
194
- expect(treeMultimap.isAVLBalanced()).toBe(true);
195
- expect(treeMultimap.getHeight()).toBe(4);
242
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
243
+ expect(treeMultiMap.getHeight()).toBe(3);
196
244
 
197
- const removed3 = treeMultimap.delete(3, undefined, true);
245
+ const removed3 = treeMultiMap.delete(3, undefined, true);
198
246
  expect(removed3 instanceof Array);
199
247
  expect(removed3[0]);
200
248
  expect(removed3[0].deleted);
201
249
  if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
202
- expect(treeMultimap.isAVLBalanced()).toBe(true);
203
- expect(treeMultimap.getHeight()).toBe(4);
250
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
251
+ expect(treeMultiMap.getHeight()).toBe(3);
204
252
 
205
- const removed8 = treeMultimap.delete(8, undefined, true);
253
+ const removed8 = treeMultiMap.delete(8, undefined, true);
206
254
  expect(removed8 instanceof Array);
207
255
  expect(removed8[0]);
208
256
  expect(removed8[0].deleted);
209
257
  if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
210
- expect(treeMultimap.isAVLBalanced()).toBe(false);
211
- expect(treeMultimap.getHeight()).toBe(4);
258
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
259
+ expect(treeMultiMap.getHeight()).toBe(3);
212
260
 
213
- const removed6 = treeMultimap.delete(6, undefined, true);
261
+ const removed6 = treeMultiMap.delete(6, undefined, true);
214
262
  expect(removed6 instanceof Array);
215
263
  expect(removed6[0]);
216
264
  expect(removed6[0].deleted);
217
265
  if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
218
- expect(treeMultimap.delete(6, undefined, true).length).toBe(0);
219
- expect(treeMultimap.isAVLBalanced()).toBe(false);
266
+ expect(treeMultiMap.delete(6, undefined, true).length).toBe(0);
267
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
220
268
 
221
- expect(treeMultimap.getHeight()).toBe(4);
269
+ expect(treeMultiMap.getHeight()).toBe(3);
222
270
 
223
- const removed7 = treeMultimap.delete(7, undefined, true);
271
+ const removed7 = treeMultiMap.delete(7, undefined, true);
224
272
  expect(removed7 instanceof Array);
225
273
  expect(removed7[0]);
226
274
  expect(removed7[0].deleted);
227
275
  if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
228
- expect(treeMultimap.isAVLBalanced()).toBe(false);
229
- expect(treeMultimap.getHeight()).toBe(4);
276
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
277
+ expect(treeMultiMap.getHeight()).toBe(3);
230
278
 
231
- const removed9 = treeMultimap.delete(9, undefined, true);
279
+ const removed9 = treeMultiMap.delete(9, undefined, true);
232
280
  expect(removed9 instanceof Array);
233
281
  expect(removed9[0]);
234
282
  expect(removed9[0].deleted);
235
283
  if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
236
- expect(treeMultimap.isAVLBalanced()).toBe(true);
237
- expect(treeMultimap.getHeight()).toBe(3);
284
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
285
+ expect(treeMultiMap.getHeight()).toBe(2);
238
286
 
239
- const removed14 = treeMultimap.delete(14, undefined, true);
287
+ const removed14 = treeMultiMap.delete(14, undefined, true);
240
288
  expect(removed14 instanceof Array);
241
289
  expect(removed14[0]);
242
290
  expect(removed14[0].deleted);
243
291
  if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
244
- expect(treeMultimap.isAVLBalanced()).toBe(true);
245
- expect(treeMultimap.getHeight()).toBe(2);
292
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
293
+ expect(treeMultiMap.getHeight()).toBe(1);
246
294
 
247
- expect(treeMultimap.isAVLBalanced()).toBe(true);
295
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
248
296
 
249
- const bfsIDs = treeMultimap.bfs(node => node.key);
297
+ const bfsIDs = treeMultiMap.bfs(node => node.key);
250
298
 
251
299
  expect(bfsIDs[0]).toBe(12);
252
300
  expect(bfsIDs[1]).toBe(2);
253
301
  expect(bfsIDs[2]).toBe(16);
254
302
 
255
- const bfsNodes = treeMultimap.bfs(node => node);
303
+ const bfsNodes = treeMultiMap.bfs(node => node);
256
304
 
257
305
  expect(bfsNodes[0].key).toBe(12);
258
306
  expect(bfsNodes[1].key).toBe(2);
259
307
  expect(bfsNodes[2].key).toBe(16);
260
308
 
261
- expect(treeMultimap.count).toBe(8);
309
+ expect(treeMultiMap.count).toBe(6);
310
+ expect(treeMultiMap.getMutableCount()).toBe(8);
262
311
  });
263
312
 
264
313
  it('should perform various operations on a Binary Search Tree with object values', () => {
@@ -287,9 +336,10 @@ describe('TreeMultiMap operations test1', () => {
287
336
 
288
337
  expect(objTreeMultiMap.root).toBeInstanceOf(TreeMultiMapNode);
289
338
 
290
- if (objTreeMultiMap.root) expect(objTreeMultiMap.root.key).toBe(11);
339
+ if (objTreeMultiMap.root) expect(objTreeMultiMap.root.key).toBe(5);
291
340
 
292
341
  expect(objTreeMultiMap.count).toBe(16);
342
+ expect(objTreeMultiMap.getMutableCount()).toBe(16);
293
343
 
294
344
  expect(objTreeMultiMap.has(6)).toBe(true);
295
345
  });
@@ -297,11 +347,11 @@ describe('TreeMultiMap operations test1', () => {
297
347
 
298
348
  describe('TreeMultiMap operations test recursively1', () => {
299
349
  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
300
- const treeMultimap = new TreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
350
+ const treeMultiMap = new TreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
301
351
 
302
- expect(treeMultimap instanceof TreeMultiMap);
303
- treeMultimap.add([11, 11]);
304
- treeMultimap.add([3, 3]);
352
+ expect(treeMultiMap instanceof TreeMultiMap);
353
+ treeMultiMap.add([11, 11]);
354
+ treeMultiMap.add([3, 3]);
305
355
  const idAndValues: [number, number][] = [
306
356
  [11, 11],
307
357
  [3, 3],
@@ -320,42 +370,43 @@ describe('TreeMultiMap operations test recursively1', () => {
320
370
  [10, 10],
321
371
  [5, 5]
322
372
  ];
323
- treeMultimap.addMany(idAndValues);
324
- expect(treeMultimap.root).toBeInstanceOf(TreeMultiMapNode);
373
+ treeMultiMap.addMany(idAndValues);
374
+ expect(treeMultiMap.root).toBeInstanceOf(TreeMultiMapNode);
325
375
 
326
- if (treeMultimap.root) expect(treeMultimap.root.key).toBe(11);
376
+ if (treeMultiMap.root) expect(treeMultiMap.root.key).toBe(5);
327
377
 
328
- expect(treeMultimap.size).toBe(16);
329
- expect(treeMultimap.count).toBe(18);
378
+ expect(treeMultiMap.size).toBe(16);
379
+ expect(treeMultiMap.count).toBe(18);
380
+ expect(treeMultiMap.getMutableCount()).toBe(18);
330
381
 
331
- expect(treeMultimap.has(6));
382
+ expect(treeMultiMap.has(6));
332
383
 
333
- expect(treeMultimap.getHeight(6)).toBe(2);
334
- expect(treeMultimap.getDepth(6)).toBe(4);
335
- const nodeId10 = treeMultimap.getNode(10);
384
+ expect(treeMultiMap.getHeight(6)).toBe(1);
385
+ expect(treeMultiMap.getDepth(6)).toBe(3);
386
+ const nodeId10 = treeMultiMap.getNode(10);
336
387
  expect(nodeId10?.key).toBe(10);
337
388
 
338
- const nodeVal9 = treeMultimap.getNode(9, node => node.value);
389
+ const nodeVal9 = treeMultiMap.getNode(9, node => node.value);
339
390
  expect(nodeVal9?.key).toBe(9);
340
391
 
341
- const nodesByCount1 = treeMultimap.getNodes(1, node => node.count);
392
+ const nodesByCount1 = treeMultiMap.getNodes(1, node => node.count);
342
393
  expect(nodesByCount1.length).toBe(14);
343
394
 
344
- const nodesByCount2 = treeMultimap.getNodes(2, node => node.count);
395
+ const nodesByCount2 = treeMultiMap.getNodes(2, node => node.count);
345
396
  expect(nodesByCount2.length).toBe(2);
346
- const leftMost = treeMultimap.getLeftMost();
397
+ const leftMost = treeMultiMap.getLeftMost();
347
398
  expect(leftMost?.key).toBe(1);
348
399
 
349
- const node15 = treeMultimap.getNode(15);
350
- const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
351
- expect(minNodeBySpecificNode?.key).toBe(15);
400
+ const node15 = treeMultiMap.getNode(15);
401
+ const minNodeBySpecificNode = node15 && treeMultiMap.getLeftMost(node15);
402
+ expect(minNodeBySpecificNode?.key).toBe(14);
352
403
 
353
404
  let subTreeSum = 0;
354
- node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
355
- expect(subTreeSum).toBe(31);
405
+ node15 && treeMultiMap.dfs(node => (subTreeSum += node.key), 'pre', 15);
406
+ expect(subTreeSum).toBe(45);
356
407
  let lesserSum = 0;
357
- expect(treeMultimap.has(9)).toBe(true);
358
- treeMultimap.lesserOrGreaterTraverse(
408
+ expect(treeMultiMap.has(9)).toBe(true);
409
+ treeMultiMap.lesserOrGreaterTraverse(
359
410
  node => {
360
411
  lesserSum += node.key;
361
412
  return node.key;
@@ -367,160 +418,161 @@ describe('TreeMultiMap operations test recursively1', () => {
367
418
 
368
419
  expect(node15 instanceof TreeMultiMapNode);
369
420
  if (node15 instanceof TreeMultiMapNode) {
370
- const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
421
+ const subTreeAdd = treeMultiMap.dfs(node => (node.count += 1), 'pre', 15);
371
422
  expect(subTreeAdd);
372
423
  }
373
- const node11 = treeMultimap.getNode(11);
424
+ const node11 = treeMultiMap.getNode(11);
374
425
  expect(node11 instanceof TreeMultiMapNode);
375
426
  if (node11 instanceof TreeMultiMapNode) {
376
- const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
427
+ const allGreaterNodesAdded = treeMultiMap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
377
428
  expect(allGreaterNodesAdded);
378
429
  }
379
430
 
380
- const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
431
+ const dfsInorderNodes = treeMultiMap.dfs(node => node, 'in');
381
432
  expect(dfsInorderNodes[0].key).toBe(1);
382
433
  expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
383
- expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
434
+ expect(treeMultiMap.isPerfectlyBalanced()).toBe(true);
384
435
 
385
- treeMultimap.perfectlyBalance();
436
+ treeMultiMap.perfectlyBalance();
386
437
 
387
- expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
388
- expect(treeMultimap.isAVLBalanced()).toBe(true);
438
+ expect(treeMultiMap.isPerfectlyBalanced()).toBe(false);
439
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
389
440
 
390
- const bfsNodesAfterBalanced = treeMultimap.bfs(node => node);
391
- expect(bfsNodesAfterBalanced[0].key).toBe(8);
441
+ const bfsNodesAfterBalanced = treeMultiMap.bfs(node => node);
442
+ expect(bfsNodesAfterBalanced[0].key).toBe(6);
392
443
  expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
393
444
 
394
- const removed11 = treeMultimap.delete(11, undefined, true);
445
+ const removed11 = treeMultiMap.delete(11, undefined, true);
395
446
  expect(removed11 instanceof Array);
396
447
  expect(removed11[0]);
397
448
  expect(removed11[0].deleted);
398
449
 
399
450
  if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
400
451
 
401
- expect(treeMultimap.isAVLBalanced()).toBe(true);
452
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
402
453
 
403
- expect(treeMultimap.getHeight(15)).toBe(2);
454
+ expect(treeMultiMap.getHeight(15)).toBe(1);
404
455
 
405
- const removed1 = treeMultimap.delete(1, undefined, true);
456
+ const removed1 = treeMultiMap.delete(1, undefined, true);
406
457
  expect(removed1 instanceof Array);
407
458
  expect(removed1[0]);
408
459
  expect(removed1[0].deleted);
409
460
  if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
410
461
 
411
- expect(treeMultimap.isAVLBalanced()).toBe(true);
462
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
412
463
 
413
- expect(treeMultimap.getHeight()).toBe(5);
464
+ expect(treeMultiMap.getHeight()).toBe(5);
414
465
 
415
- const removed4 = treeMultimap.delete(4, undefined, true);
466
+ const removed4 = treeMultiMap.delete(4, undefined, true);
416
467
  expect(removed4 instanceof Array);
417
468
  expect(removed4[0]);
418
469
  expect(removed4[0].deleted);
419
470
  if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
420
471
 
421
- expect(treeMultimap.isAVLBalanced()).toBe(true);
422
- expect(treeMultimap.getHeight()).toBe(5);
472
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
473
+ expect(treeMultiMap.getHeight()).toBe(5);
423
474
 
424
- const removed10 = treeMultimap.delete(10, undefined, true);
475
+ const removed10 = treeMultiMap.delete(10, undefined, true);
425
476
  expect(removed10 instanceof Array);
426
477
  expect(removed10[0]);
427
478
  expect(removed10[0].deleted);
428
479
  if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
429
- expect(treeMultimap.isAVLBalanced()).toBe(false);
480
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
430
481
 
431
- expect(treeMultimap.getHeight()).toBe(5);
482
+ expect(treeMultiMap.getHeight()).toBe(4);
432
483
 
433
- const removed15 = treeMultimap.delete(15, undefined, true);
484
+ const removed15 = treeMultiMap.delete(15, undefined, true);
434
485
  expect(removed15 instanceof Array);
435
486
  expect(removed15[0]);
436
487
  expect(removed15[0].deleted);
437
488
  if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
438
489
 
439
- expect(treeMultimap.isAVLBalanced()).toBe(true);
440
- expect(treeMultimap.getHeight()).toBe(4);
490
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
491
+ expect(treeMultiMap.getHeight()).toBe(3);
441
492
 
442
- const removed5 = treeMultimap.delete(5, undefined, true);
493
+ const removed5 = treeMultiMap.delete(5, undefined, true);
443
494
  expect(removed5 instanceof Array);
444
495
  expect(removed5[0]);
445
496
  expect(removed5[0].deleted);
446
497
  if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
447
498
 
448
- expect(treeMultimap.isAVLBalanced()).toBe(true);
449
- expect(treeMultimap.getHeight()).toBe(4);
499
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
500
+ expect(treeMultiMap.getHeight()).toBe(3);
450
501
 
451
- const removed13 = treeMultimap.delete(13, undefined, true);
502
+ const removed13 = treeMultiMap.delete(13, undefined, true);
452
503
  expect(removed13 instanceof Array);
453
504
  expect(removed13[0]);
454
505
  expect(removed13[0].deleted);
455
506
  if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
456
- expect(treeMultimap.isAVLBalanced()).toBe(true);
457
- expect(treeMultimap.getHeight()).toBe(4);
507
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
508
+ expect(treeMultiMap.getHeight()).toBe(3);
458
509
 
459
- const removed3 = treeMultimap.delete(3, undefined, true);
510
+ const removed3 = treeMultiMap.delete(3, undefined, true);
460
511
  expect(removed3 instanceof Array);
461
512
  expect(removed3[0]);
462
513
  expect(removed3[0].deleted);
463
514
  if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
464
- expect(treeMultimap.isAVLBalanced()).toBe(true);
465
- expect(treeMultimap.getHeight()).toBe(4);
515
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
516
+ expect(treeMultiMap.getHeight()).toBe(3);
466
517
 
467
- const removed8 = treeMultimap.delete(8, undefined, true);
518
+ const removed8 = treeMultiMap.delete(8, undefined, true);
468
519
  expect(removed8 instanceof Array);
469
520
  expect(removed8[0]);
470
521
  expect(removed8[0].deleted);
471
522
  if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
472
- expect(treeMultimap.isAVLBalanced()).toBe(false);
473
- expect(treeMultimap.getHeight()).toBe(4);
523
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
524
+ expect(treeMultiMap.getHeight()).toBe(3);
474
525
 
475
- const removed6 = treeMultimap.delete(6, undefined, true);
526
+ const removed6 = treeMultiMap.delete(6, undefined, true);
476
527
  expect(removed6 instanceof Array);
477
528
  expect(removed6[0]);
478
529
  expect(removed6[0].deleted);
479
530
  if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
480
- expect(treeMultimap.delete(6, undefined, true).length).toBe(0);
481
- expect(treeMultimap.isAVLBalanced()).toBe(false);
531
+ expect(treeMultiMap.delete(6, undefined, true).length).toBe(0);
532
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
482
533
 
483
- expect(treeMultimap.getHeight()).toBe(4);
534
+ expect(treeMultiMap.getHeight()).toBe(3);
484
535
 
485
- const removed7 = treeMultimap.delete(7, undefined, true);
536
+ const removed7 = treeMultiMap.delete(7, undefined, true);
486
537
  expect(removed7 instanceof Array);
487
538
  expect(removed7[0]);
488
539
  expect(removed7[0].deleted);
489
540
  if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
490
- expect(treeMultimap.isAVLBalanced()).toBe(false);
491
- expect(treeMultimap.getHeight()).toBe(4);
541
+ expect(treeMultiMap.isAVLBalanced()).toBe(false);
542
+ expect(treeMultiMap.getHeight()).toBe(3);
492
543
 
493
- const removed9 = treeMultimap.delete(9, undefined, true);
544
+ const removed9 = treeMultiMap.delete(9, undefined, true);
494
545
  expect(removed9 instanceof Array);
495
546
  expect(removed9[0]);
496
547
  expect(removed9[0].deleted);
497
548
  if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
498
- expect(treeMultimap.isAVLBalanced()).toBe(true);
499
- expect(treeMultimap.getHeight()).toBe(3);
549
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
550
+ expect(treeMultiMap.getHeight()).toBe(2);
500
551
 
501
- const removed14 = treeMultimap.delete(14, undefined, true);
552
+ const removed14 = treeMultiMap.delete(14, undefined, true);
502
553
  expect(removed14 instanceof Array);
503
554
  expect(removed14[0]);
504
555
  expect(removed14[0].deleted);
505
556
  if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
506
- expect(treeMultimap.isAVLBalanced()).toBe(true);
507
- expect(treeMultimap.getHeight()).toBe(2);
557
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
558
+ expect(treeMultiMap.getHeight()).toBe(1);
508
559
 
509
- expect(treeMultimap.isAVLBalanced()).toBe(true);
560
+ expect(treeMultiMap.isAVLBalanced()).toBe(true);
510
561
 
511
- const bfsIDs = treeMultimap.bfs(node => node.key);
562
+ const bfsIDs = treeMultiMap.bfs(node => node.key);
512
563
 
513
564
  expect(bfsIDs[0]).toBe(12);
514
565
  expect(bfsIDs[1]).toBe(2);
515
566
  expect(bfsIDs[2]).toBe(16);
516
567
 
517
- const bfsNodes = treeMultimap.bfs(node => node);
568
+ const bfsNodes = treeMultiMap.bfs(node => node);
518
569
 
519
570
  expect(bfsNodes[0].key).toBe(12);
520
571
  expect(bfsNodes[1].key).toBe(2);
521
572
  expect(bfsNodes[2].key).toBe(16);
522
573
 
523
- expect(treeMultimap.count).toBe(8);
574
+ expect(treeMultiMap.count).toBe(6);
575
+ expect(treeMultiMap.getMutableCount()).toBe(8);
524
576
  });
525
577
 
526
578
  it('should perform various operations on a Binary Search Tree with object values', () => {
@@ -549,17 +601,18 @@ describe('TreeMultiMap operations test recursively1', () => {
549
601
 
550
602
  expect(objTreeMultiMap.root).toBeInstanceOf(TreeMultiMapNode);
551
603
 
552
- if (objTreeMultiMap.root) expect(objTreeMultiMap.root.key).toBe(11);
604
+ if (objTreeMultiMap.root) expect(objTreeMultiMap.root.key).toBe(5);
553
605
 
554
606
  expect(objTreeMultiMap.count).toBe(16);
607
+ expect(objTreeMultiMap.getMutableCount()).toBe(16);
555
608
 
556
609
  expect(objTreeMultiMap.has(6)).toBe(true);
557
610
  });
558
611
  });
559
612
 
560
- describe('TreeMultiMap Performance test', function () {
613
+ describe('TreeMultiMap delete test', function () {
561
614
  const treeMS = new TreeMultiMap<number, number>();
562
- const inputSize = 1000; // Adjust input sizes as needed
615
+ const inputSize = 100; // Adjust input sizes as needed
563
616
 
564
617
  beforeEach(() => {
565
618
  treeMS.clear();
@@ -571,52 +624,117 @@ describe('TreeMultiMap Performance test', function () {
571
624
  isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
572
625
  });
573
626
 
574
- it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
575
- const start = performance.now();
627
+ it('The structure remains normal after random deletion', function () {
576
628
  for (let i = 0; i < inputSize; i++) {
577
629
  treeMS.add(i);
578
630
  }
579
631
 
580
- isDebug && console.log('---add', performance.now() - start);
581
- const startL = performance.now();
582
- treeMS.lesserOrGreaterTraverse(node => (node.count += 1), CP.lt, inputSize / 2);
583
- isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
632
+ for (let i = 0; i < inputSize; i++) {
633
+ const num = getRandomInt(0, inputSize - 1);
634
+ treeMS.delete(num);
635
+ }
636
+
637
+ let nanCount = 0;
638
+ const dfs = (cur: TreeMultiMapNode<number>) => {
639
+ if (isNaN(cur.key)) nanCount++;
640
+ if (cur.left) dfs(cur.left);
641
+ if (cur.right) dfs(cur.right);
642
+ };
643
+ if (treeMS.root) dfs(treeMS.root);
644
+
645
+ expect(treeMS.size).toBeLessThanOrEqual(inputSize);
646
+ expect(treeMS.getHeight()).toBeGreaterThan(Math.log2(inputSize));
647
+ expect(treeMS.getHeight()).toBeLessThan(Math.log2(inputSize) * 2);
648
+
649
+ expect(nanCount).toBeLessThanOrEqual(inputSize);
650
+ });
651
+
652
+ it(`Random additions, complete deletions of structures are normal`, function () {
653
+ for (let i = 0; i < inputSize; i++) {
654
+ const num = getRandomInt(0, inputSize - 1);
655
+ if (i === 0 && isDebug) console.log(`first:`, num);
656
+ treeMS.add(num);
657
+ }
658
+
659
+ for (let i = 0; i < inputSize; i++) {
660
+ treeMS.delete(i, undefined, true);
661
+ }
662
+
663
+ let nanCount = 0;
664
+ const dfs = (cur: TreeMultiMapNode<number>) => {
665
+ if (isNaN(cur.key)) nanCount++;
666
+ if (cur.left) dfs(cur.left);
667
+ if (cur.right) dfs(cur.right);
668
+ };
669
+ if (treeMS.root) dfs(treeMS.root);
670
+
671
+ expect(treeMS.size).toBe(0);
672
+ expect(treeMS.getHeight()).toBe(0);
673
+ expect(nanCount).toBeLessThanOrEqual(inputSize);
674
+
675
+ isDebug && treeMS.print();
676
+ });
677
+
678
+ it(`Random additions, count deletions of structures are normal`, function () {
679
+ for (let i = 0; i < inputSize; i++) {
680
+ const num = getRandomInt(0, inputSize - 1);
681
+ if (i === 0 && isDebug) console.log(`first:`, num);
682
+ treeMS.add(num);
683
+ }
684
+
685
+ for (let i = 0; i < inputSize; i++) {
686
+ treeMS.delete(i);
687
+ }
688
+
689
+ let nanCount = 0;
690
+ const dfs = (cur: TreeMultiMapNode<number>) => {
691
+ if (isNaN(cur.key)) nanCount++;
692
+ if (cur.left) dfs(cur.left);
693
+ if (cur.right) dfs(cur.right);
694
+ };
695
+ if (treeMS.root) dfs(treeMS.root);
696
+
697
+ expect(treeMS.size).toBeGreaterThanOrEqual(0);
698
+ expect(treeMS.getHeight()).toBeGreaterThanOrEqual(0);
699
+ expect(nanCount).toBeLessThanOrEqual(inputSize);
700
+
701
+ isDebug && treeMS.print();
584
702
  });
585
703
 
586
704
  it('should the clone method', () => {
587
- function checkTreeStructure(treeMultimap: TreeMultiMap<string, number>) {
588
- expect(treeMultimap.size).toBe(4);
589
- expect(treeMultimap.root?.key).toBe('4');
590
- expect(treeMultimap.root?.left?.key).toBe('1');
591
- expect(treeMultimap.root?.left?.left?.key).toBe(NaN);
592
- expect(treeMultimap.root?.left?.right?.key).toBe('2');
593
- expect(treeMultimap.root?.right?.key).toBe('5');
594
- expect(treeMultimap.root?.right?.left?.key).toBe(NaN);
595
- expect(treeMultimap.root?.right?.right?.key).toBe(NaN);
705
+ function checkTreeStructure(treeMultiMap: TreeMultiMap<string, number>) {
706
+ expect(treeMultiMap.size).toBe(4);
707
+ expect(treeMultiMap.root?.key).toBe('2');
708
+ expect(treeMultiMap.root?.left?.key).toBe('1');
709
+ expect(treeMultiMap.root?.left?.left?.key).toBe(NaN);
710
+ expect(treeMultiMap.root?.left?.right?.key).toBe(NaN);
711
+ expect(treeMultiMap.root?.right?.key).toBe('4');
712
+ expect(treeMultiMap.root?.right?.left?.key).toBe(NaN);
713
+ expect(treeMultiMap.root?.right?.right?.key).toBe('5');
596
714
  }
597
715
 
598
- const treeMultimap = new TreeMultiMap<string, number>();
599
- treeMultimap.addMany([
716
+ const treeMultiMap = new TreeMultiMap<string, number>();
717
+ treeMultiMap.addMany([
600
718
  ['2', 2],
601
719
  ['4', 4],
602
720
  ['5', 5],
603
721
  ['3', 3],
604
722
  ['1', 1]
605
723
  ]);
606
- expect(treeMultimap.size).toBe(5);
607
- expect(treeMultimap.root?.key).toBe('3');
608
- expect(treeMultimap.root?.left?.key).toBe('1');
609
- expect(treeMultimap.root?.left?.left?.key).toBe(NaN);
610
- expect(treeMultimap.root?.left?.right?.key).toBe('2');
611
- expect(treeMultimap.root?.right?.key).toBe('4');
612
- expect(treeMultimap.root?.right?.left?.key).toBe(NaN);
613
- expect(treeMultimap.root?.right?.right?.key).toBe('5');
614
- treeMultimap.delete('3');
615
- checkTreeStructure(treeMultimap);
616
- const cloned = treeMultimap.clone();
724
+ expect(treeMultiMap.size).toBe(5);
725
+ expect(treeMultiMap.root?.key).toBe('2');
726
+ expect(treeMultiMap.root?.left?.key).toBe('1');
727
+ expect(treeMultiMap.root?.left?.left?.key).toBe(NaN);
728
+ expect(treeMultiMap.root?.left?.right?.key).toBe(NaN);
729
+ expect(treeMultiMap.root?.right?.key).toBe('4');
730
+ expect(treeMultiMap.root?.right?.left?.key).toBe(`3`);
731
+ expect(treeMultiMap.root?.right?.right?.key).toBe('5');
732
+ treeMultiMap.delete('3');
733
+ checkTreeStructure(treeMultiMap);
734
+ const cloned = treeMultiMap.clone();
617
735
  checkTreeStructure(cloned);
618
736
  cloned.delete('1');
619
- expect(treeMultimap.size).toBe(4);
737
+ expect(treeMultiMap.size).toBe(4);
620
738
  expect(cloned.size).toBe(3);
621
739
  });
622
740
  });
@@ -689,9 +807,10 @@ describe('TreeMultiMap iterative methods test', () => {
689
807
 
690
808
  test('should clone work well', () => {
691
809
  expect(treeMM.count).toBe(21);
810
+ expect(treeMM.getMutableCount()).toBe(21);
692
811
  const cloned = treeMM.clone();
693
- expect(cloned.root?.left?.key).toBe(NaN);
694
- expect(cloned.root?.right?.value).toBe('b');
812
+ expect(cloned.root?.left?.key).toBe(1);
813
+ expect(cloned.root?.right?.value).toBe('c');
695
814
  });
696
815
 
697
816
  test('should keys', () => {