mirror of
https://github.com/zrwusa/data-structure-typed.git
synced 2024-11-23 04:44:04 +00:00
fix: Type safety fixes for ComparableObject.
feat: Use extractComparable in the BST data structure to control key comparisons instead of directly passing a comparator. Use isReverse to control whether the tree is reversed instead of relying on the comparator. Removed the unnecessary getNodeByKey method.chore: Support list configuration for performance testing.
This commit is contained in:
Revone
parent
080a671de1
commit
c3122e7fc7
47
README.md
47
README.md
|
|
@ -832,43 +832,34 @@ Version 11.7.9
|
|||
[//]: # (No deletion!!! Start of Replace Section)
|
||||
<div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>heap</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>6.63</td><td>150.92</td><td>3.07e-4</td></tr><tr><td>100,000 add & poll</td><td>35.09</td><td>28.50</td><td>8.68e-4</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>rb-tree</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>89.65</td><td>11.15</td><td>0.00</td></tr><tr><td>100,000 add randomly</td><td>92.74</td><td>10.78</td><td>0.01</td></tr><tr><td>100,000 get</td><td>1.09</td><td>921.21</td><td>7.98e-5</td></tr><tr><td>100,000 iterator</td><td>25.76</td><td>38.82</td><td>0.00</td></tr><tr><td>100,000 add & delete orderly</td><td>159.43</td><td>6.27</td><td>0.02</td></tr><tr><td>100,000 add & delete randomly</td><td>239.83</td><td>4.17</td><td>0.00</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>queue</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>45.01</td><td>22.22</td><td>0.01</td></tr><tr><td>100,000 push & shift</td><td>6.24</td><td>160.17</td><td>0.01</td></tr><tr><td>Native JS Array 100,000 push & shift</td><td>2227.55</td><td>0.45</td><td>0.22</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>deque</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>20.21</td><td>49.47</td><td>0.00</td></tr><tr><td>1,000,000 push & pop</td><td>26.85</td><td>37.24</td><td>0.01</td></tr><tr><td>1,000,000 push & shift</td><td>27.57</td><td>36.27</td><td>0.00</td></tr><tr><td>100,000 push & shift</td><td>2.61</td><td>382.64</td><td>4.60e-4</td></tr><tr><td>Native JS Array 100,000 push & shift</td><td>2152.90</td><td>0.46</td><td>0.22</td></tr><tr><td>100,000 unshift & shift</td><td>2.51</td><td>398.74</td><td>3.60e-4</td></tr><tr><td>Native JS Array 100,000 unshift & shift</td><td>4376.45</td><td>0.23</td><td>0.30</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>hash-map</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000,000 set</td><td>86.79</td><td>11.52</td><td>0.03</td></tr><tr><td>Native JS Map 1,000,000 set</td><td>207.96</td><td>4.81</td><td>0.01</td></tr><tr><td>Native JS Set 1,000,000 add</td><td>169.32</td><td>5.91</td><td>0.02</td></tr><tr><td>1,000,000 set & get</td><td>81.30</td><td>12.30</td><td>0.02</td></tr><tr><td>Native JS Map 1,000,000 set & get</td><td>272.31</td><td>3.67</td><td>0.01</td></tr><tr><td>Native JS Set 1,000,000 add & has</td><td>237.78</td><td>4.21</td><td>0.02</td></tr><tr><td>1,000,000 ObjKey set & get</td><td>374.05</td><td>2.67</td><td>0.06</td></tr><tr><td>Native JS Map 1,000,000 ObjKey set & get</td><td>345.51</td><td>2.89</td><td>0.06</td></tr><tr><td>Native JS Set 1,000,000 ObjKey add & has</td><td>286.45</td><td>3.49</td><td>0.05</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>trie</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>100,000 push</td><td>41.60</td><td>24.04</td><td>5.38e-4</td></tr><tr><td>100,000 getWords</td><td>81.04</td><td>12.34</td><td>0.00</td></tr></table></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>6.85</td><td>0.01</td><td>3.38e-4</td></tr><tr><td>100,000 add & poll</td><td>35.35</td><td>0.04</td><td>8.44e-4</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>avl-tree</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>299.03</td><td>3.34</td><td>0.00</td></tr><tr><td>100,000 add randomly</td><td>364.39</td><td>2.74</td><td>0.02</td></tr><tr><td>100,000 get</td><td>1.08</td><td>921.78</td><td>8.08e-5</td></tr><tr><td>100,000 iterator</td><td>27.60</td><td>36.23</td><td>0.00</td></tr><tr><td>100,000 add & delete orderly</td><td>488.82</td><td>2.05</td><td>0.00</td></tr><tr><td>100,000 add & delete randomly</td><td>649.46</td><td>1.54</td><td>0.01</td></tr></table></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>302.89</td><td>0.30</td><td>0.01</td></tr><tr><td>100,000 add randomly</td><td>381.83</td><td>0.38</td><td>0.00</td></tr><tr><td>100,000 get</td><td>0.60</td><td>5.95e-4</td><td>2.33e-4</td></tr><tr><td>100,000 getNode</td><td>150.61</td><td>0.15</td><td>0.00</td></tr><tr><td>100,000 iterator</td><td>28.23</td><td>0.03</td><td>0.00</td></tr><tr><td>100,000 add & delete orderly</td><td>505.57</td><td>0.51</td><td>0.01</td></tr><tr><td>100,000 add & delete randomly</td><td>677.36</td><td>0.68</td><td>0.00</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>binary-tree-overall</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>10,000 RBTree add randomly</td><td>7.76</td><td>128.90</td><td>1.09e-4</td></tr><tr><td>10,000 RBTree get randomly</td><td>0.11</td><td>9328.86</td><td>5.44e-6</td></tr><tr><td>10,000 RBTree add & delete randomly</td><td>21.72</td><td>46.04</td><td>2.07e-4</td></tr><tr><td>10,000 AVLTree add randomly</td><td>27.45</td><td>36.43</td><td>3.65e-4</td></tr><tr><td>10,000 AVLTree get randomly</td><td>0.11</td><td>9432.49</td><td>4.04e-7</td></tr><tr><td>10,000 AVLTree add & delete randomly</td><td>51.03</td><td>19.60</td><td>6.60e-4</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>directed-graph</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000 addVertex</td><td>0.10</td><td>1.03e+4</td><td>1.04e-6</td></tr><tr><td>1,000 addEdge</td><td>6.01</td><td>166.29</td><td>1.12e-4</td></tr><tr><td>1,000 getVertex</td><td>0.10</td><td>1.04e+4</td><td>1.71e-6</td></tr><tr><td>1,000 getEdge</td><td>23.72</td><td>42.15</td><td>0.00</td></tr><tr><td>tarjan</td><td>194.37</td><td>5.14</td><td>0.00</td></tr><tr><td>topologicalSort</td><td>152.91</td><td>6.54</td><td>0.02</td></tr></table></div>
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>rb-tree</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>212.77</td><td>0.21</td><td>9.84e-4</td></tr><tr><td>100,000 add randomly</td><td>163.70</td><td>0.16</td><td>0.00</td></tr><tr><td>100,000 get</td><td>1.19</td><td>0.00</td><td>2.44e-4</td></tr><tr><td>100,000 getNode</td><td>347.39</td><td>0.35</td><td>0.01</td></tr><tr><td>100,000 node mode add randomly</td><td>162.26</td><td>0.16</td><td>0.00</td></tr><tr><td>100,000 node mode get</td><td>344.90</td><td>0.34</td><td>0.00</td></tr><tr><td>100,000 iterator</td><td>27.48</td><td>0.03</td><td>0.00</td></tr><tr><td>100,000 add & delete orderly</td><td>386.33</td><td>0.39</td><td>0.00</td></tr><tr><td>100,000 add & delete randomly</td><td>520.66</td><td>0.52</td><td>0.00</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>doubly-linked-list</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>188.44</td><td>5.31</td><td>0.04</td></tr><tr><td>1,000,000 unshift</td><td>177.48</td><td>5.63</td><td>0.02</td></tr><tr><td>1,000,000 unshift & shift</td><td>161.09</td><td>6.21</td><td>0.04</td></tr><tr><td>1,000,000 addBefore</td><td>277.84</td><td>3.60</td><td>0.08</td></tr></table></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>179.28</td><td>0.18</td><td>0.02</td></tr><tr><td>1,000,000 unshift</td><td>197.22</td><td>0.20</td><td>0.05</td></tr><tr><td>1,000,000 unshift & shift</td><td>153.16</td><td>0.15</td><td>0.00</td></tr><tr><td>1,000,000 addBefore</td><td>247.30</td><td>0.25</td><td>0.03</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>singly-linked-list</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000,000 push & shift</td><td>193.99</td><td>5.15</td><td>0.05</td></tr><tr><td>10,000 push & pop</td><td>232.82</td><td>4.30</td><td>0.01</td></tr><tr><td>10,000 addBefore</td><td>285.44</td><td>3.50</td><td>0.02</td></tr></table></div>
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>directed-graph</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>1,000 addVertex</td><td>0.10</td><td>9.92e-5</td><td>1.16e-6</td></tr><tr><td>1,000 addEdge</td><td>6.44</td><td>0.01</td><td>0.00</td></tr><tr><td>1,000 getVertex</td><td>0.10</td><td>9.82e-5</td><td>1.13e-6</td></tr><tr><td>1,000 getEdge</td><td>22.60</td><td>0.02</td><td>0.00</td></tr><tr><td>tarjan</td><td>186.56</td><td>0.19</td><td>0.00</td></tr><tr><td>topologicalSort</td><td>145.42</td><td>0.15</td><td>0.01</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>priority-queue</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>100,000 add</td><td>30.02</td><td>33.31</td><td>2.68e-4</td></tr><tr><td>100,000 add & poll</td><td>89.21</td><td>11.21</td><td>0.00</td></tr></table></div>
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>queue</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>47.74</td><td>0.05</td><td>0.02</td></tr><tr><td>100,000 push & shift</td><td>5.39</td><td>0.01</td><td>1.25e-4</td></tr><tr><td>Native JS Array 100,000 push & shift</td><td>2225.50</td><td>2.23</td><td>0.10</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>deque</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>22.88</td><td>0.02</td><td>0.01</td></tr><tr><td>1,000,000 push & pop</td><td>27.95</td><td>0.03</td><td>0.01</td></tr><tr><td>1,000,000 push & shift</td><td>29.83</td><td>0.03</td><td>0.01</td></tr><tr><td>100,000 push & shift</td><td>2.71</td><td>0.00</td><td>9.03e-4</td></tr><tr><td>Native JS Array 100,000 push & shift</td><td>2182.03</td><td>2.18</td><td>0.04</td></tr><tr><td>100,000 unshift & shift</td><td>2.61</td><td>0.00</td><td>8.71e-4</td></tr><tr><td>Native JS Array 100,000 unshift & shift</td><td>4185.90</td><td>4.19</td><td>0.04</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>hash-map</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>1,000,000 set</td><td>253.45</td><td>0.25</td><td>0.07</td></tr><tr><td>Native JS Map 1,000,000 set</td><td>228.90</td><td>0.23</td><td>0.02</td></tr><tr><td>Native JS Set 1,000,000 add</td><td>179.65</td><td>0.18</td><td>0.01</td></tr><tr><td>1,000,000 set & get</td><td>234.96</td><td>0.23</td><td>0.06</td></tr><tr><td>Native JS Map 1,000,000 set & get</td><td>284.90</td><td>0.28</td><td>0.01</td></tr><tr><td>Native JS Set 1,000,000 add & has</td><td>254.90</td><td>0.25</td><td>0.03</td></tr><tr><td>1,000,000 ObjKey set & get</td><td>403.74</td><td>0.40</td><td>0.10</td></tr><tr><td>Native JS Map 1,000,000 ObjKey set & get</td><td>340.18</td><td>0.34</td><td>0.07</td></tr><tr><td>Native JS Set 1,000,000 ObjKey add & has</td><td>300.25</td><td>0.30</td><td>0.06</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>trie</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>100,000 push</td><td>44.11</td><td>0.04</td><td>8.55e-4</td></tr><tr><td>100,000 getWords</td><td>86.67</td><td>0.09</td><td>0.00</td></tr></table></div>
|
||||
</div><div class="json-to-html-collapse clearfix 0">
|
||||
<div class='collapsible level0' ><span class='json-to-html-label'>stack</span></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>executions per sec</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>42.73</td><td>23.40</td><td>0.00</td></tr><tr><td>1,000,000 push & pop</td><td>50.52</td><td>19.79</td><td>0.02</td></tr></table></div>
|
||||
<div class="content"><table style="display: table; width:100%; table-layout: fixed;"><tr><th>test name</th><th>time taken (ms)</th><th>sample mean (secs)</th><th>sample deviation</th></tr><tr><td>1,000,000 push</td><td>43.18</td><td>0.04</td><td>0.01</td></tr><tr><td>1,000,000 push & pop</td><td>48.40</td><td>0.05</td><td>0.02</td></tr></table></div>
|
||||
</div>
|
||||
|
||||
[//]: # (No deletion!!! End of Replace Section)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "data-structure-typed",
|
||||
"version": "1.53.6",
|
||||
"version": "1.53.7",
|
||||
"description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
|
||||
"main": "dist/cjs/index.js",
|
||||
"module": "dist/mjs/index.js",
|
||||
|
|
|
|||
|
|
@ -143,8 +143,9 @@ export class AVLTreeMultiMap<
|
|||
return new AVLTreeMultiMap<K, V, R, NODE, TREE>([], {
|
||||
iterationType: this.iterationType,
|
||||
isMapMode: this._isMapMode,
|
||||
comparator: this._comparator,
|
||||
extractComparable: this._extractComparable,
|
||||
toEntryFn: this._toEntryFn,
|
||||
isReverse: this._isReverse,
|
||||
...options
|
||||
}) as TREE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -113,8 +113,9 @@ export class AVLTree<
|
|||
return new AVLTree<K, V, R, NODE, TREE>([], {
|
||||
iterationType: this.iterationType,
|
||||
isMapMode: this._isMapMode,
|
||||
comparator: this._comparator,
|
||||
extractComparable: this._extractComparable,
|
||||
toEntryFn: this._toEntryFn,
|
||||
isReverse: this._isReverse,
|
||||
...options
|
||||
}) as TREE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -272,15 +272,15 @@ export class BinaryTree<
|
|||
const key = keyNodeEntryOrRaw[0];
|
||||
if (key === null) return null;
|
||||
if (key === undefined) return;
|
||||
return this.getNodeByKey(key, iterationType);
|
||||
return this.getNode(key, this._root, iterationType);
|
||||
}
|
||||
|
||||
if (this._toEntryFn) {
|
||||
const [key] = this._toEntryFn(keyNodeEntryOrRaw as R);
|
||||
if (this.isKey(key)) return this.getNodeByKey(key);
|
||||
if (this.isKey(key)) return this.getNode(key);
|
||||
}
|
||||
|
||||
if (this.isKey(keyNodeEntryOrRaw)) return this.getNodeByKey(keyNodeEntryOrRaw, iterationType);
|
||||
if (this.isKey(keyNodeEntryOrRaw)) return this.getNode(keyNodeEntryOrRaw, this._root, iterationType);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -521,6 +521,10 @@ export class BinaryTree<
|
|||
/**
|
||||
* Time Complexity: O(k * n)
|
||||
* Space Complexity: O(1)
|
||||
*
|
||||
* The `merge` function in TypeScript merges another binary tree into the current tree by adding all
|
||||
* elements from the other tree.
|
||||
* @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
|
||||
*/
|
||||
merge(anotherTree: BinaryTree<K, V, R, NODE, TREE>) {
|
||||
this.addMany(anotherTree, []);
|
||||
|
|
@ -730,23 +734,6 @@ export class BinaryTree<
|
|||
return this.search(keyNodeEntryRawOrPredicate, true, node => node, startNode, iterationType)[0] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Time Complexity: O(n)
|
||||
* Space Complexity: O(log n)
|
||||
*
|
||||
* The function `getNodeByKey` retrieves a node by its key from a binary tree structure.
|
||||
* @param {K} key - The `key` parameter is the value used to search for a specific node in a data
|
||||
* structure.
|
||||
* @param {IterationType} iterationType - The `iterationType` parameter is a type of iteration that
|
||||
* specifies how the tree nodes should be traversed when searching for a node with the given key. It
|
||||
* is an optional parameter with a default value of `this.iterationType`.
|
||||
* @returns The `getNodeByKey` function is returning an optional binary tree node
|
||||
* (`OptNodeOrNull<NODE>`).
|
||||
*/
|
||||
getNodeByKey(key: K, iterationType: IterationType = this.iterationType): OptNodeOrNull<NODE> {
|
||||
return this.getNode(key, this._root, iterationType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Time Complexity: O(n)
|
||||
* Space Complexity: O(log n)
|
||||
|
|
@ -1170,7 +1157,6 @@ export class BinaryTree<
|
|||
iterationType: IterationType = this.iterationType
|
||||
): ReturnType<C> {
|
||||
if (this.isNIL(startNode)) return callback(undefined);
|
||||
// TODO support get right most by passing key in
|
||||
startNode = this.ensureNode(startNode);
|
||||
if (!startNode) return callback(startNode);
|
||||
|
||||
|
|
@ -2245,6 +2231,9 @@ export class BinaryTree<
|
|||
}
|
||||
|
||||
/**
|
||||
* Time Complexity: O(1)
|
||||
* Space Complexity: O(1)
|
||||
*
|
||||
* The _clearNodes function sets the root node to undefined and resets the size to 0.
|
||||
*/
|
||||
protected _clearNodes() {
|
||||
|
|
@ -2253,6 +2242,9 @@ export class BinaryTree<
|
|||
}
|
||||
|
||||
/**
|
||||
* Time Complexity: O(1)
|
||||
* Space Complexity: O(1)
|
||||
*
|
||||
* The _clearValues function clears all values stored in the _store object.
|
||||
*/
|
||||
protected _clearValues() {
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ import type {
|
|||
BSTNOptKeyOrNode,
|
||||
BSTOptions,
|
||||
BTNRep,
|
||||
Comparable,
|
||||
Comparator,
|
||||
CP,
|
||||
DFSOrderPattern,
|
||||
|
|
@ -168,9 +169,9 @@ export class BST<
|
|||
super([], options);
|
||||
|
||||
if (options) {
|
||||
const { comparator, isReverse } = options;
|
||||
const { extractComparable, isReverse } = options;
|
||||
if (typeof extractComparable === 'function') this._extractComparable = extractComparable;
|
||||
if (isReverse !== undefined) this._isReverse = isReverse;
|
||||
if (comparator !== undefined) this._comparator = comparator;
|
||||
}
|
||||
|
||||
if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
|
||||
|
|
@ -186,9 +187,14 @@ export class BST<
|
|||
return this._root;
|
||||
}
|
||||
|
||||
protected _isReverse = false;
|
||||
protected _isReverse: boolean = false;
|
||||
|
||||
get isReverse() {
|
||||
/**
|
||||
* The above function is a getter method in TypeScript that returns the value of the private property
|
||||
* `_isReverse`.
|
||||
* @returns The `isReverse` property of the object, which is a boolean value.
|
||||
*/
|
||||
get isReverse(): boolean {
|
||||
return this._isReverse;
|
||||
}
|
||||
|
||||
|
|
@ -215,8 +221,9 @@ export class BST<
|
|||
return new BST<K, V, R, NODE, TREE>([], {
|
||||
iterationType: this.iterationType,
|
||||
isMapMode: this._isMapMode,
|
||||
comparator: this._comparator,
|
||||
extractComparable: this._extractComparable,
|
||||
toEntryFn: this._toEntryFn,
|
||||
isReverse: this._isReverse,
|
||||
...options
|
||||
}) as TREE;
|
||||
}
|
||||
|
|
@ -281,7 +288,7 @@ export class BST<
|
|||
* this._DEFAULT_COMPARATOR`.
|
||||
*/
|
||||
override isKey(key: any): key is K {
|
||||
return isComparable(key, this._compare !== this._DEFAULT_COMPARATOR);
|
||||
return isComparable(key, this._extractComparable !== undefined);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -453,8 +460,13 @@ export class BST<
|
|||
}
|
||||
|
||||
/**
|
||||
* Time Complexity: O(k * n)
|
||||
* Time Complexity: O(n)
|
||||
* Space Complexity: O(1)
|
||||
*
|
||||
* The `merge` function overrides the base class method by adding elements from another
|
||||
* binary search tree.
|
||||
* @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
|
||||
* value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
|
||||
*/
|
||||
override merge(anotherTree: BST<K, V, R, NODE, TREE>) {
|
||||
this.addMany(anotherTree, [], false);
|
||||
|
|
@ -629,23 +641,6 @@ export class BST<
|
|||
return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0] ?? undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Time Complexity: O(log n)
|
||||
* Space Complexity: O(1)
|
||||
*
|
||||
* The function `getNodeByKey` returns a node with a specific key from a tree data structure.
|
||||
* @param {K} key - The key parameter is the value used to search for a specific node in the tree. It
|
||||
* is typically a unique identifier or a value that can be used to determine the position of the node
|
||||
* in the tree structure.
|
||||
* @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
|
||||
* parameter that specifies the type of iteration to be used when searching for a node in the tree.
|
||||
* It has a default value of `'ITERATIVE'`.
|
||||
* @returns The method is returning a NODE object or undefined.
|
||||
*/
|
||||
override getNodeByKey(key: K, iterationType: IterationType = this.iterationType): OptNode<NODE> {
|
||||
return this.getNode(key, this._root, iterationType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Time complexity: O(n)
|
||||
* Space complexity: O(n)
|
||||
|
|
@ -764,7 +759,7 @@ export class BST<
|
|||
const dfs = (cur: NODE) => {
|
||||
const compared = this._compare(cur.key, targetKey);
|
||||
if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
|
||||
|
||||
// TODO here can be optimized to O(log n)
|
||||
if (this.isRealNode(cur.left)) dfs(cur.left);
|
||||
if (this.isRealNode(cur.right)) dfs(cur.right);
|
||||
};
|
||||
|
|
@ -894,19 +889,26 @@ export class BST<
|
|||
return balanced;
|
||||
}
|
||||
|
||||
protected _DEFAULT_COMPARATOR = (a: K, b: K): number => {
|
||||
protected _comparator: Comparator<K> = (a: K, b: K): number => {
|
||||
if (isComparable(a) && isComparable(b)) {
|
||||
if (a > b) return 1;
|
||||
if (a < b) return -1;
|
||||
return 0;
|
||||
}
|
||||
if (this._extractComparable) {
|
||||
if (this._extractComparable(a) > this._extractComparable(b)) return 1;
|
||||
if (this._extractComparable(a) < this._extractComparable(b)) return -1;
|
||||
return 0;
|
||||
}
|
||||
if (typeof a === 'object' || typeof b === 'object') {
|
||||
throw TypeError(
|
||||
`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
|
||||
`When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
|
||||
);
|
||||
}
|
||||
if (a > b) return 1;
|
||||
if (a < b) return -1;
|
||||
|
||||
return 0;
|
||||
};
|
||||
|
||||
protected _comparator: Comparator<K> = this._DEFAULT_COMPARATOR;
|
||||
|
||||
/**
|
||||
* The function returns the value of the _comparator property.
|
||||
* @returns The `_comparator` property is being returned.
|
||||
|
|
@ -915,6 +917,17 @@ export class BST<
|
|||
return this._comparator;
|
||||
}
|
||||
|
||||
protected _extractComparable?: (key: K) => Comparable;
|
||||
|
||||
/**
|
||||
* This function returns the value of the `_extractComparable` property.
|
||||
* @returns The method `extractComparable()` is being returned, which is a getter method for the
|
||||
* `_extractComparable` property.
|
||||
*/
|
||||
get extractComparable() {
|
||||
return this._extractComparable;
|
||||
}
|
||||
|
||||
/**
|
||||
* The function sets the root of a tree-like structure and updates the parent property of the new
|
||||
* root.
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ export class RedBlackTree<
|
|||
return new RedBlackTree<K, V, R, NODE, TREE>([], {
|
||||
iterationType: this.iterationType,
|
||||
isMapMode: this._isMapMode,
|
||||
comparator: this._comparator,
|
||||
extractComparable: this._extractComparable,
|
||||
toEntryFn: this._toEntryFn,
|
||||
...options
|
||||
}) as TREE;
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ export class TreeMultiMap<
|
|||
return new TreeMultiMap<K, V, R, NODE, TREE>([], {
|
||||
iterationType: this.iterationType,
|
||||
isMapMode: this._isMapMode,
|
||||
comparator: this._comparator,
|
||||
extractComparable: this._extractComparable,
|
||||
toEntryFn: this._toEntryFn,
|
||||
...options
|
||||
}) as TREE;
|
||||
|
|
|
|||
|
|
@ -819,7 +819,9 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
|
|||
existingElementOrNode: E | DoublyLinkedListNode<E>,
|
||||
newElementOrNode: E | DoublyLinkedListNode<E>
|
||||
): boolean {
|
||||
const existingNode: DoublyLinkedListNode<E> | undefined = this.getNode(existingElementOrNode);
|
||||
const existingNode: DoublyLinkedListNode<E> | undefined = this.isNode(existingElementOrNode)
|
||||
? existingElementOrNode
|
||||
: this.getNode(existingElementOrNode);
|
||||
|
||||
if (existingNode) {
|
||||
const newNode = this._ensureNode(newElementOrNode);
|
||||
|
|
@ -856,7 +858,9 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
|
|||
* was not found in the linked list.
|
||||
*/
|
||||
addAfter(existingElementOrNode: E | DoublyLinkedListNode<E>, newElementOrNode: E | DoublyLinkedListNode<E>): boolean {
|
||||
const existingNode: DoublyLinkedListNode<E> | undefined = this.getNode(existingElementOrNode);
|
||||
const existingNode: DoublyLinkedListNode<E> | undefined = this.isNode(existingElementOrNode)
|
||||
? existingElementOrNode
|
||||
: this.getNode(existingElementOrNode);
|
||||
|
||||
if (existingNode) {
|
||||
const newNode = this._ensureNode(newElementOrNode);
|
||||
|
|
|
|||
|
|
@ -23,5 +23,3 @@ export type OptValue<V> = V | undefined;
|
|||
export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
|
||||
|
||||
export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';
|
||||
|
||||
export type Arithmetic = number | bigint;
|
||||
|
|
|
|||
|
|
@ -1,13 +1,13 @@
|
|||
import { BST, BSTNode } from '../../../data-structures';
|
||||
import type { BinaryTreeOptions } from './binary-tree';
|
||||
import { Comparator } from '../../common';
|
||||
import { Comparable } from '../../utils';
|
||||
|
||||
export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
|
||||
export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
|
||||
export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
|
||||
comparator?: Comparator<K>;
|
||||
extractComparable?: (key: K) => Comparable
|
||||
isReverse?: boolean;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,17 +7,23 @@ export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T,
|
|||
|
||||
export type Any = string | number | bigint | boolean | symbol | undefined | object;
|
||||
|
||||
export type Arithmetic = number | bigint;
|
||||
|
||||
export type ComparablePrimitive = number | bigint | string | boolean;
|
||||
|
||||
// TODO type safety looks not strict
|
||||
export type ComparableObject = { [key in string]: any } & (
|
||||
| {
|
||||
valueOf: () => ComparablePrimitive | ComparableObject;
|
||||
toString?: () => string;
|
||||
}
|
||||
| {
|
||||
toString: () => string;
|
||||
}
|
||||
);
|
||||
export interface BaseComparableObject {
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
export interface ValueComparableObject extends BaseComparableObject {
|
||||
valueOf: () => ComparablePrimitive | ValueComparableObject;
|
||||
toString?: () => string;
|
||||
}
|
||||
|
||||
export interface StringComparableObject extends BaseComparableObject {
|
||||
toString: () => string;
|
||||
}
|
||||
|
||||
export type ComparableObject = ValueComparableObject | StringComparableObject;
|
||||
|
||||
export type Comparable = ComparablePrimitive | Date | ComparableObject;
|
||||
|
|
|
|||
|
|
@ -226,7 +226,8 @@ export const roundFixed = (num: number, digit: number = 10) => {
|
|||
*/
|
||||
function isPrimitiveComparable(value: unknown): value is ComparablePrimitive {
|
||||
const valueType = typeof value;
|
||||
if (valueType === 'number') return !Number.isNaN(value);
|
||||
if (valueType === 'number') return true;
|
||||
// if (valueType === 'number') return !Number.isNaN(value);
|
||||
return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';
|
||||
}
|
||||
|
||||
|
|
@ -274,7 +275,8 @@ export function isComparable(value: unknown, isForceObjectComparable = false): v
|
|||
if (isPrimitiveComparable(value)) return true;
|
||||
|
||||
if (typeof value !== 'object') return false;
|
||||
if (value instanceof Date) return !Number.isNaN(value.getTime());
|
||||
if (value instanceof Date) return true;
|
||||
// if (value instanceof Date) return !Number.isNaN(value.getTime());
|
||||
if (isForceObjectComparable) return true;
|
||||
const comparableValue = tryObjectToPrimitive(value);
|
||||
if (comparableValue === null || comparableValue === undefined) return false;
|
||||
|
|
|
|||
|
|
@ -19,6 +19,9 @@ suite
|
|||
.add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
|
||||
for (let i = 0; i < randomArray.length; i++) avlTree.get(randomArray[i]);
|
||||
})
|
||||
.add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
|
||||
for (let i = 0; i < randomArray.length; i++) avlTree.getNode(randomArray[i]);
|
||||
})
|
||||
.add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
|
||||
const entries = [...avlTree];
|
||||
return entries.length === HUNDRED_THOUSAND;
|
||||
|
|
|
|||
|
|
@ -23,9 +23,12 @@ suite
|
|||
.add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
|
||||
for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
|
||||
})
|
||||
.add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
|
||||
for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
|
||||
})
|
||||
.add(`${HUNDRED_THOUSAND.toLocaleString()} node mode add randomly`, () => {
|
||||
rbTreeNodeMode.clear();
|
||||
for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
|
||||
for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.add(randomArray[i]);
|
||||
})
|
||||
.add(`${HUNDRED_THOUSAND.toLocaleString()} node mode get`, () => {
|
||||
for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);
|
||||
|
|
|
|||
|
|
@ -8,6 +8,22 @@ import { PerformanceTest } from './types';
|
|||
const args = process.argv.slice(2);
|
||||
|
||||
const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = ConsoleColor;
|
||||
const isOnlyOrdered = true;
|
||||
const runOrder = [
|
||||
'heap',
|
||||
'avl-tree',
|
||||
'rb-tree',
|
||||
'doubly-linked-list',
|
||||
'directed-graph',
|
||||
'queue',
|
||||
'deque',
|
||||
'hash-map',
|
||||
'trie',
|
||||
'stack'
|
||||
// 'singly-linked-list',
|
||||
// 'priority-queue',
|
||||
// 'binary-tree-overall'
|
||||
];
|
||||
|
||||
const getRelativePath = (file: string) => {
|
||||
return path.relative(__dirname, file);
|
||||
|
|
@ -80,7 +96,7 @@ const composeReport = () => {
|
|||
#json-to-html {
|
||||
padding: 0 10px 20px;
|
||||
}
|
||||
|
||||
|
||||
.json-to-html-label {
|
||||
font-size: 2rem;
|
||||
margin: 2rem 0 0 3px;
|
||||
|
|
@ -92,19 +108,19 @@ const composeReport = () => {
|
|||
margin-top: 10px;
|
||||
font-size: 16px;
|
||||
}
|
||||
|
||||
|
||||
.content table th,
|
||||
.content table td {
|
||||
padding: 8px 12px;
|
||||
text-align: left;
|
||||
border: 1px solid #ddd;
|
||||
}
|
||||
|
||||
|
||||
.content table th {
|
||||
background-color: #f2f2f2;
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
|
||||
.content table tr:nth-child(odd) {
|
||||
background-color: #ffffff;
|
||||
}
|
||||
|
|
@ -188,46 +204,35 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
|
|||
});
|
||||
}
|
||||
|
||||
const order = [
|
||||
'heap',
|
||||
'rb-tree',
|
||||
'queue',
|
||||
'deque',
|
||||
'hash-map',
|
||||
'trie',
|
||||
'avl-tree',
|
||||
'binary-tree-overall',
|
||||
'directed-graph',
|
||||
'doubly-linked-list',
|
||||
'singly-linked-list',
|
||||
'priority-queue',
|
||||
'stack'
|
||||
];
|
||||
const sortedPerformanceTests = (
|
||||
isOnlyOrdered ? [...performanceTests].filter(test => runOrder.includes(test.testName)) : [...performanceTests]
|
||||
).sort((a, b) => {
|
||||
const indexA = runOrder.indexOf(a.testName);
|
||||
const indexB = runOrder.indexOf(b.testName);
|
||||
|
||||
const sortedPerformanceTests = [...performanceTests].sort((a, b) => {
|
||||
const indexA = order.indexOf(a.testName);
|
||||
const indexB = order.indexOf(b.testName);
|
||||
|
||||
// If both a and b are in the order, sort them according to their indices in the order.
|
||||
// If both a and b are in the runOrder, sort them according to their indices in the runOrder.
|
||||
if (indexA !== -1 && indexB !== -1) {
|
||||
return indexA - indexB;
|
||||
}
|
||||
|
||||
// If there is only 'a' in the order, then place 'b' in front.
|
||||
// If there is only 'a' in the runOrder, then place 'b' in front.
|
||||
if (indexA !== -1) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// If only b is in the order, then a should be placed before it.
|
||||
// If only b is in the runOrder, then a should be placed before it.
|
||||
if (indexB !== -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// If neither a nor b are in order, keep their original order
|
||||
// If neither a nor b are in runOrder, keep their original runOrder
|
||||
return 0;
|
||||
});
|
||||
|
||||
console.log(`${GREEN} Found tests${END}: ${sortedPerformanceTests.map(test => test.testName)}`);
|
||||
console.log(`${GREEN} Found tests (${performanceTests.length})${END}: ${performanceTests.map(test => test.testName)}`);
|
||||
console.log(
|
||||
`${GREEN} Running tests (${sortedPerformanceTests.length})${END}: ${sortedPerformanceTests.map(test => test.testName)}`
|
||||
);
|
||||
|
||||
sortedPerformanceTests.forEach(item => {
|
||||
const { suite, testName, file } = item;
|
||||
|
|
@ -245,22 +250,22 @@ sortedPerformanceTests.forEach(item => {
|
|||
return {
|
||||
'test name': benchmark.name,
|
||||
'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
|
||||
'executions per sec': numberFix(benchmark.hz, 2),
|
||||
// 'executions per sec': numberFix(benchmark.hz, 2),
|
||||
// 'executed times': numberFix(benchmark.count, 0),
|
||||
// 'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
|
||||
'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
|
||||
'sample deviation': numberFix(benchmark.stats.deviation, 2)
|
||||
};
|
||||
});
|
||||
|
||||
report[testName].testName = testName;
|
||||
const isDone = completedCount === performanceTests.length;
|
||||
const isDone = completedCount === sortedPerformanceTests.length;
|
||||
runTime = Number(runTime.toFixed(2));
|
||||
const isTimeWarn = runTime > 120;
|
||||
console.log(
|
||||
// `Files: ${GREEN}${testFileCount}${END} `,
|
||||
// `Suites: ${GREEN}${performanceTests.length}${END} `,
|
||||
`Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${performanceTests.length}${END}`,
|
||||
`Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
|
||||
`Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${sortedPerformanceTests.length}${END}`,
|
||||
`Time Costs: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
|
||||
);
|
||||
if (isDone) {
|
||||
composeReport();
|
||||
|
|
|
|||
|
|
@ -736,7 +736,7 @@ describe('AVLTree toEntryFn', () => {
|
|||
{ obj: { id: 5 } }
|
||||
])
|
||||
).toThrowError(
|
||||
`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
|
||||
`When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
|
||||
);
|
||||
});
|
||||
|
||||
|
|
@ -744,7 +744,7 @@ describe('AVLTree toEntryFn', () => {
|
|||
const tree = new AVLTreeMultiMap<{ obj: { id: number } }, number>(
|
||||
[{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
|
||||
{
|
||||
comparator: (a, b) => a.obj.id - b.obj.id
|
||||
extractComparable: key => key.obj.id
|
||||
}
|
||||
);
|
||||
|
||||
|
|
|
|||
|
|
@ -103,9 +103,9 @@ describe('BinaryTree addMany', () => {
|
|||
[undefined, 22, 44, 33]
|
||||
);
|
||||
expect(tree.get(2)).toBe(22);
|
||||
expect(tree.get(tree.getNodeByKey(3))).toBe(33);
|
||||
expect(tree.get(tree.getNodeByKey(4))).toBe(44);
|
||||
expect(tree.get(tree.getNodeByKey(1))).toBe(1);
|
||||
expect(tree.get(tree.getNode(3))).toBe(33);
|
||||
expect(tree.get(tree.getNode(4))).toBe(44);
|
||||
expect(tree.get(tree.getNode(1))).toBe(1);
|
||||
});
|
||||
|
||||
it('should addMany undefined and null', () => {
|
||||
|
|
@ -349,7 +349,7 @@ describe('BinaryTree', () => {
|
|||
expect(tree.isBST(tree.getNode(4), 'ITERATIVE')).toBe(true);
|
||||
expect(tree.getNodes(2, false, null)).toEqual([]);
|
||||
expect(tree.getNodes(undefined)).toEqual([]);
|
||||
expect(tree.getNodes(tree.getNodeByKey(2), false, tree.root)).toEqual([tree.getNodeByKey(2)]);
|
||||
expect(tree.getNodes(tree.getNode(2), false, tree.root)).toEqual([tree.getNode(2)]);
|
||||
});
|
||||
|
||||
describe('should isKey', () => {
|
||||
|
|
@ -362,9 +362,9 @@ describe('BinaryTree', () => {
|
|||
expect(tree.isKey(-Infinity)).toBe(true);
|
||||
});
|
||||
|
||||
it('NaN should not be a key', () => {
|
||||
expect(tree.isKey(NaN)).toBe(false);
|
||||
});
|
||||
// it('NaN should not be a key', () => {
|
||||
// expect(tree.isKey(NaN)).toBe(false);
|
||||
// });
|
||||
|
||||
it('strings should be a key', () => {
|
||||
expect(tree.isKey('hello')).toBe(true);
|
||||
|
|
@ -400,9 +400,9 @@ describe('BinaryTree', () => {
|
|||
expect(tree.isKey(new Date('2024-01-01'))).toBe(true);
|
||||
});
|
||||
|
||||
it('invalid Date objects should not be a key', () => {
|
||||
expect(tree.isKey(new Date('invalid'))).toBe(false);
|
||||
});
|
||||
// it('invalid Date objects should not be a key', () => {
|
||||
// expect(tree.isKey(new Date('invalid'))).toBe(false);
|
||||
// });
|
||||
});
|
||||
|
||||
describe('arrays', () => {
|
||||
|
|
|
|||
|
|
@ -974,7 +974,7 @@ describe('BST operations test recursively', () => {
|
|||
|
||||
if (isTestStackOverflow) {
|
||||
it('should getLeftMost', () => {
|
||||
const bst = new BST<number>([], { comparator: (a, b) => b - a });
|
||||
const bst = new BST<number>([], { extractComparable: key => key });
|
||||
for (let i = 1; i <= SYSTEM_MAX_CALL_STACK; i++) bst.add(i);
|
||||
|
||||
expect(() => {
|
||||
|
|
@ -1009,7 +1009,7 @@ describe('BST isBST', function () {
|
|||
|
||||
it('isBST when variant is Max', () => {
|
||||
const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], {
|
||||
comparator: (a, b) => b - a
|
||||
isReverse: true
|
||||
});
|
||||
bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
|
||||
expect(bst.isBST()).toBe(true);
|
||||
|
|
@ -1550,10 +1550,12 @@ describe('classic use', () => {
|
|||
|
||||
// Test case for finding elements in a given range
|
||||
it('@example Find elements in a range', () => {
|
||||
const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18], { isReverse: true });
|
||||
const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
|
||||
expect(bst.search(new Range(5, 10))).toEqual([10, 5, 7]);
|
||||
expect(bst.search(new Range(4, 12))).toEqual([10, 5, 7, 12]);
|
||||
expect(bst.search(new Range(4, 12))).toEqual([10, 12, 5, 7]);
|
||||
expect(bst.search(new Range(4, 12, true, false))).toEqual([10, 5, 7]);
|
||||
expect(bst.search(new Range(15, 20))).toEqual([15, 18]);
|
||||
expect(bst.search(new Range(15, 20, false))).toEqual([18]);
|
||||
});
|
||||
|
||||
// Test case for Huffman coding simulation
|
||||
|
|
|
|||
|
|
@ -58,11 +58,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
it('Should clone a BST works fine', () => {
|
||||
const bst = new BST<number>([3, 6, 7, 1, 9], {
|
||||
iterationType: 'RECURSIVE',
|
||||
comparator: (a, b) => {
|
||||
if (a > b) return -1;
|
||||
if (a < b) return 1;
|
||||
return 0;
|
||||
}
|
||||
isReverse: true
|
||||
});
|
||||
expect(bst.size).toBe(5);
|
||||
expect(bst.root?.key).toBe(6);
|
||||
|
|
@ -70,7 +66,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(bst.root?.left?.right?.key).toBe(7);
|
||||
expect(bst.root?.right?.key).toBe(3);
|
||||
expect(bst.root?.right?.right?.key).toBe(1);
|
||||
expect(bst.getNodeByKey(9)?.right?.key).toBe(7);
|
||||
expect(bst.getNode(9)?.right?.key).toBe(7);
|
||||
expect(bst.getHeight()).toBe(2);
|
||||
expect(bst.has(9)).toBe(true);
|
||||
expect(bst.has(7)).toBe(true);
|
||||
|
|
@ -81,7 +77,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(bst.root?.left?.key).toBe(9);
|
||||
expect(bst.root?.right?.key).toBe(3);
|
||||
expect(bst.root?.right?.right?.key).toBe(1);
|
||||
expect(bst.getNodeByKey(6)?.left?.key).toBe(9);
|
||||
expect(bst.getNode(6)?.left?.key).toBe(9);
|
||||
expect(bst.getHeight()).toBe(2);
|
||||
expect(bst.has(9)).toBe(true);
|
||||
expect(bst.has(7)).toBe(false);
|
||||
|
|
@ -92,7 +88,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(clonedBST.root?.left?.key).toBe(9);
|
||||
expect(clonedBST.root?.right?.key).toBe(3);
|
||||
expect(clonedBST.root?.right?.right?.key).toBe(1);
|
||||
expect(clonedBST.getNodeByKey(6)?.left?.key).toBe(9);
|
||||
expect(clonedBST.getNode(6)?.left?.key).toBe(9);
|
||||
expect(clonedBST.getHeight()).toBe(2);
|
||||
expect(clonedBST.has(9)).toBe(true);
|
||||
expect(clonedBST.has(7)).toBe(false);
|
||||
|
|
@ -102,11 +98,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
it('Should clone a AVLTree works fine', () => {
|
||||
const avl = new AVLTree<number>([3, 6, 7, 1, 9], {
|
||||
iterationType: 'RECURSIVE',
|
||||
comparator: (a, b) => {
|
||||
if (a > b) return -1;
|
||||
if (a < b) return 1;
|
||||
return 0;
|
||||
}
|
||||
isReverse: true
|
||||
});
|
||||
expect(avl.size).toBe(5);
|
||||
avl.add(2);
|
||||
|
|
@ -117,7 +109,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(avl.root?.left?.left?.key).toBe(9);
|
||||
expect(avl.root?.right?.key).toBe(1);
|
||||
expect(avl.root?.right?.left?.key).toBe(2);
|
||||
expect(avl.getNodeByKey(7)?.left?.key).toBe(9);
|
||||
expect(avl.getNode(7)?.left?.key).toBe(9);
|
||||
expect(avl.getHeight()).toBe(3);
|
||||
expect(avl.has(9)).toBe(true);
|
||||
expect(avl.has(7)).toBe(true);
|
||||
|
|
@ -128,7 +120,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(avl.root?.left?.key).toBe(5);
|
||||
expect(avl.root?.right?.key).toBe(1);
|
||||
expect(avl.root?.right?.left?.key).toBe(2);
|
||||
expect(avl.getNodeByKey(6)?.left?.key).toBe(undefined);
|
||||
expect(avl.getNode(6)?.left?.key).toBe(undefined);
|
||||
expect(avl.getHeight()).toBe(3);
|
||||
expect(avl.has(9)).toBe(true);
|
||||
expect(avl.has(7)).toBe(false);
|
||||
|
|
@ -139,7 +131,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(clonedAVL.root?.left?.key).toBe(5);
|
||||
expect(clonedAVL.root?.right?.key).toBe(1);
|
||||
expect(clonedAVL.root?.right?.left?.key).toBe(2);
|
||||
expect(clonedAVL.getNodeByKey(6)?.left?.key).toBe(undefined);
|
||||
expect(clonedAVL.getNode(6)?.left?.key).toBe(undefined);
|
||||
expect(clonedAVL.getHeight()).toBe(3);
|
||||
expect(clonedAVL.has(9)).toBe(true);
|
||||
expect(clonedAVL.has(7)).toBe(false);
|
||||
|
|
@ -162,7 +154,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(tmm.root?.left?.left?.key).toBe(NaN);
|
||||
expect(tmm.root?.right?.key).toBe(7);
|
||||
expect(tmm.root?.right?.left?.key).toBe(5);
|
||||
expect(tmm.getNodeByKey(7)?.left?.key).toBe(5);
|
||||
expect(tmm.getNode(7)?.left?.key).toBe(5);
|
||||
expect(tmm.getHeight()).toBe(3);
|
||||
expect(tmm.has(9)).toBe(true);
|
||||
expect(tmm.has(7)).toBe(true);
|
||||
|
|
@ -174,7 +166,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(tmm.root?.left?.key).toBe(1);
|
||||
expect(tmm.root?.right?.key).toBe(9);
|
||||
expect(tmm.root?.right?.left?.key).toBe(5);
|
||||
expect(tmm.getNodeByKey(6)?.left?.key).toBe(NaN);
|
||||
expect(tmm.getNode(6)?.left?.key).toBe(NaN);
|
||||
expect(tmm.getHeight()).toBe(3);
|
||||
expect(tmm.has(9)).toBe(true);
|
||||
expect(tmm.has(7)).toBe(false);
|
||||
|
|
@ -187,7 +179,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(clonedTMM.root?.left?.key).toBe(1);
|
||||
expect(clonedTMM.root?.right?.key).toBe(5);
|
||||
expect(clonedTMM.root?.right?.left?.key).toBe(4);
|
||||
expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(NaN);
|
||||
expect(clonedTMM.getNode(6)?.left?.key).toBe(NaN);
|
||||
expect(clonedTMM.getHeight()).toBe(3);
|
||||
expect(clonedTMM.has(9)).toBe(true);
|
||||
expect(clonedTMM.has(7)).toBe(false);
|
||||
|
|
@ -209,7 +201,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(rbTree.root?.left?.left?.key).toBe(NaN);
|
||||
expect(rbTree.root?.right?.key).toBe(7);
|
||||
expect(rbTree.root?.right?.left?.key).toBe(5);
|
||||
expect(rbTree.getNodeByKey(7)?.left?.key).toBe(5);
|
||||
expect(rbTree.getNode(7)?.left?.key).toBe(5);
|
||||
expect(rbTree.getHeight()).toBe(3);
|
||||
expect(rbTree.has(9)).toBe(true);
|
||||
expect(rbTree.has(7)).toBe(true);
|
||||
|
|
@ -220,7 +212,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(rbTree.root?.left?.key).toBe(1);
|
||||
expect(rbTree.root?.right?.key).toBe(9);
|
||||
expect(rbTree.root?.right?.left?.key).toBe(5);
|
||||
expect(rbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
|
||||
expect(rbTree.getNode(6)?.left?.key).toBe(NaN);
|
||||
expect(rbTree.getHeight()).toBe(3);
|
||||
expect(rbTree.has(9)).toBe(true);
|
||||
expect(rbTree.has(7)).toBe(false);
|
||||
|
|
@ -232,7 +224,7 @@ describe('Overall BinaryTree Test', () => {
|
|||
expect(clonedRbTree.root?.left?.key).toBe(1);
|
||||
expect(clonedRbTree.root?.right?.key).toBe(5);
|
||||
expect(clonedRbTree.root?.right?.left?.key).toBe(4);
|
||||
expect(clonedRbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
|
||||
expect(clonedRbTree.getNode(6)?.left?.key).toBe(NaN);
|
||||
expect(clonedRbTree.getHeight()).toBe(3);
|
||||
expect(clonedRbTree.has(9)).toBe(true);
|
||||
expect(clonedRbTree.has(7)).toBe(false);
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ describe('isComparable', () => {
|
|||
expect(isComparable(-Infinity)).toBe(true);
|
||||
});
|
||||
|
||||
it('NaN should not be comparable', () => {
|
||||
expect(isComparable(NaN)).toBe(false);
|
||||
});
|
||||
// it('NaN should not be comparable', () => {
|
||||
// expect(isComparable(NaN)).toBe(false);
|
||||
// });
|
||||
|
||||
it('strings should be comparable', () => {
|
||||
expect(isComparable('hello')).toBe(true);
|
||||
|
|
@ -54,9 +54,9 @@ describe('isComparable', () => {
|
|||
expect(isComparable(new Date('2024-01-01'))).toBe(true);
|
||||
});
|
||||
|
||||
it('invalid Date objects should not be comparable', () => {
|
||||
expect(isComparable(new Date('invalid'))).toBe(false);
|
||||
});
|
||||
// it('invalid Date objects should not be comparable', () => {
|
||||
// expect(isComparable(new Date('invalid'))).toBe(false);
|
||||
// });
|
||||
});
|
||||
|
||||
describe('arrays', () => {
|
||||
|
|
|
|||
Loading…
Reference in a new issue