Gathering detailed insights and metrics for @hoangcung1804npm/voluptatum-earum-temporibus
Gathering detailed insights and metrics for @hoangcung1804npm/voluptatum-earum-temporibus
npm install @hoangcung1804npm/voluptatum-earum-temporibusTypescript
Module System
Node Version
NPM Version
JavaScript (100%)
Total Downloads
0
Last Day
0
Last Week
0
Last Month
0
Last Year
0
MIT License
3,516 Commits
1 Branches
1 Contributors
Updated on Jul 12, 2025
Latest Version
1.0.0
Package Id
@hoangcung1804npm/voluptatum-earum-temporibus@1.0.0
Unpacked Size
58.01 kB
Size
12.65 kB
File Count
10
NPM Version
10.5.0
Node Version
20.12.2
Published on
Apr 29, 2024
Cumulative downloads
Total Downloads
Last Day
0%
NaN
Compared to previous day
Last Week
0%
NaN
Compared to previous week
Last Month
0%
NaN
Compared to previous month
Last Year
0%
NaN
Compared to previous year
26
1npm i @hoangcung1804npm/voluptatum-earum-temporibus --save
1yarn add @hoangcung1804npm/voluptatum-earum-temporibus
1import { 2 Heap, Graph, Queue, Deque, PriorityQueue, BST, Trie, DoublyLinkedList, 3 AVLTree, SinglyLinkedList, DirectedGraph, RedBlackTree, TreeMultiMap, 4 DirectedVertex, Stack, AVLTreeNode 5} from '@hoangcung1804npm/voluptatum-earum-temporibus';
If you only want to use a specific data structure independently, you can install it separately, for example, by running
1npm i heap-typed --save
Do you envy C++ with STL (std::), Python with collections, and Java with java.util ? Well, no need to envy
anymore! JavaScript and TypeScript now have @hoangcung1804npm/voluptatum-earum-temporibus.Benchmark compared with C++ STL.
API standards aligned with ES6 and Java. Usability is comparable to Python
Performance surpasses that of native JS/TS
| Method | Time Taken | Data Scale | Belongs To | big O |
|---|---|---|---|---|
| Queue.push & shift | 5.83 ms | 100K | Ours | O(1) |
| Array.push & shift | 2829.59 ms | 100K | Native JS | O(n) |
| Deque.unshift & shift | 2.44 ms | 100K | Ours | O(1) |
| Array.unshift & shift | 4750.37 ms | 100K | Native JS | O(n) |
| HashMap.set | 122.51 ms | 1M | Ours | O(1) |
| Map.set | 223.80 ms | 1M | Native JS | O(1) |
| Set.add | 185.06 ms | 1M | Native JS | O(1) |
In java.utils, you need to memorize a table for all sequential data structures(Queue, Deque, LinkedList),
| Java ArrayList | Java Queue | Java ArrayDeque | Java LinkedList |
|---|---|---|---|
| add | offer | push | push |
| remove | poll | removeLast | removeLast |
| remove | poll | removeFirst | removeFirst |
| add(0, element) | offerFirst | unshift | unshift |
whereas in our @hoangcung1804npm/voluptatum-earum-temporibus, you only need to remember four methods: push, pop, shift, and unshift for all sequential data structures(Queue, Deque, DoublyLinkedList, SinglyLinkedList and Array).
We provide data structures that are not available in JS/TS
| Data Structure | Unit Test | Perf Test | API Doc | NPM | Downloads |
|---|---|---|---|---|---|
| Binary Tree |  | | Docs | NPM |  |
| Binary Search Tree (BST) | | | Docs | NPM |  |
| AVL Tree | | | Docs | NPM |  |
| Red Black Tree | | | Docs | NPM |  |
| Tree Multimap | | | Docs | NPM |  |
| Heap | | | Docs | NPM |  |
| Priority Queue | | | Docs | NPM |  |
| Max Priority Queue | | | Docs | NPM |  |
| Min Priority Queue | | | Docs | NPM |  |
| Trie | | | Docs | NPM |  |
| Graph | | | Docs | NPM |  |
| Directed Graph | | | Docs | NPM |  |
| Undirected Graph | | | Docs | NPM |  |
| Queue | | | Docs | NPM |  |
| Deque | | | Docs | NPM |  |
| Hash Map | | | Docs | ||
| Linked List | | | Docs | NPM |  |
| Singly Linked List | | | Docs | NPM |  |
| Doubly Linked List | | | Docs | NPM |  |
| Stack | | | Docs | NPM |  |
| Segment Tree | | Docs | |||
| Binary Indexed Tree | | Docs |
Try it out, or you can run your own code using our visual tool
1import { RedBlackTree } from '@hoangcung1804npm/voluptatum-earum-temporibus'; 2 3const rbTree = new RedBlackTree<number>(); 4rbTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]) 5rbTree.isAVLBalanced(); // true 6rbTree.delete(10); 7rbTree.isAVLBalanced(); // true 8rbTree.print() 9// ___6________ 10// / \ 11// ___4_ ___11________ 12// / \ / \ 13// _2_ 5 _8_ ____14__ 14// / \ / \ / \ 15// 1 3 7 9 12__ 15__ 16// \ \ 17// 13 16
1import { RedBlackTree } from '@hoangcung1804npm/voluptatum-earum-temporibus'; 2 3const rbTree = new RedBlackTree(); 4rbTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]) 5rbTree.isAVLBalanced(); // true 6rbTree.delete(10); 7rbTree.isAVLBalanced(); // true 8rbTree.print() 9// ___6________ 10// / \ 11// ___4_ ___11________ 12// / \ / \ 13// _2_ 5 _8_ ____14__ 14// / \ / \ / \ 15// 1 3 7 9 12__ 15__ 16// \ \ 17// 13 16
1const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8]; 2const orgStrArr = ["trie", "trial", "trick", "trip", "tree", "trend", "triangle", "track", "trace", "transmit"]; 3const entries = [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]; 4 5const queue = new Queue(orgArr); 6queue.print(); 7// [6, 1, 2, 7, 5, 3, 4, 9, 8] 8 9const deque = new Deque(orgArr); 10deque.print(); 11// [6, 1, 2, 7, 5, 3, 4, 9, 8] 12 13const sList = new SinglyLinkedList(orgArr); 14sList.print(); 15// [6, 1, 2, 7, 5, 3, 4, 9, 8] 16 17const dList = new DoublyLinkedList(orgArr); 18dList.print(); 19// [6, 1, 2, 7, 5, 3, 4, 9, 8] 20 21const stack = new Stack(orgArr); 22stack.print(); 23// [6, 1, 2, 7, 5, 3, 4, 9, 8] 24 25const minHeap = new MinHeap(orgArr); 26minHeap.print(); 27// [1, 5, 2, 7, 6, 3, 4, 9, 8] 28 29const maxPQ = new MaxPriorityQueue(orgArr); 30maxPQ.print(); 31// [9, 8, 4, 7, 5, 2, 3, 1, 6] 32 33const biTree = new BinaryTree(entries); 34biTree.print(); 35// ___6___ 36// / \ 37// ___1_ _2_ 38// / \ / \ 39// _7_ 5 3 4 40// / \ 41// 9 8 42 43const bst = new BST(entries); 44bst.print(); 45// _____5___ 46// / \ 47// _2_ _7_ 48// / \ / \ 49// 1 3_ 6 8_ 50// \ \ 51// 4 9 52 53 54const rbTree = new RedBlackTree(entries); 55rbTree.print(); 56// ___4___ 57// / \ 58// _2_ _6___ 59// / \ / \ 60// 1 3 5 _8_ 61// / \ 62// 7 9 63 64 65const avl = new AVLTree(entries); 66avl.print(); 67// ___4___ 68// / \ 69// _2_ _6___ 70// / \ / \ 71// 1 3 5 _8_ 72// / \ 73// 7 9 74 75const treeMulti = new TreeMultiMap(entries); 76treeMulti.print(); 77// ___4___ 78// / \ 79// _2_ _6___ 80// / \ / \ 81// 1 3 5 _8_ 82// / \ 83// 7 9 84 85const hm = new HashMap(entries); 86hm.print() 87// [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]] 88 89const rbTreeH = new RedBlackTree(hm); 90rbTreeH.print(); 91// ___4___ 92// / \ 93// _2_ _6___ 94// / \ / \ 95// 1 3 5 _8_ 96// / \ 97// 7 9 98 99const pq = new MinPriorityQueue(orgArr); 100pq.print(); 101// [1, 5, 2, 7, 6, 3, 4, 9, 8] 102 103const bst1 = new BST(pq); 104bst1.print(); 105// _____5___ 106// / \ 107// _2_ _7_ 108// / \ / \ 109// 1 3_ 6 8_ 110// \ \ 111// 4 9 112 113const dq1 = new Deque(orgArr); 114dq1.print(); 115// [6, 1, 2, 7, 5, 3, 4, 9, 8] 116const rbTree1 = new RedBlackTree(dq1); 117rbTree1.print(); 118// _____5___ 119// / \ 120// _2___ _7___ 121// / \ / \ 122// 1 _4 6 _9 123// / / 124// 3 8 125 126 127const trie2 = new Trie(orgStrArr); 128trie2.print(); 129// ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit'] 130const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) }); 131heap2.print(); 132// ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle'] 133const dq2 = new Deque(heap2); 134dq2.print(); 135// ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle'] 136const entries2 = dq2.map((el, i) => [i, el]); 137const avl2 = new AVLTree(entries2); 138avl2.print(); 139// ___3_______ 140// / \ 141// _1_ ___7_ 142// / \ / \ 143// 0 2 _5_ 8_ 144// / \ \ 145// 4 6 9
1import { BST, BSTNode } from '@hoangcung1804npm/voluptatum-earum-temporibus'; 2 3const bst = new BST<number>(); 4bst.add(11); 5bst.add(3); 6bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]); 7bst.size === 16; // true 8bst.has(6); // true 9const node6 = bst.getNode(6); // BSTNode 10bst.getHeight(6) === 2; // true 11bst.getHeight() === 5; // true 12bst.getDepth(6) === 3; // true 13 14bst.getLeftMost()?.key === 1; // true 15 16bst.delete(6); 17bst.get(6); // undefined 18bst.isAVLBalanced(); // true 19bst.bfs()[0] === 11; // true 20bst.print() 21// ______________11_____ 22// / \ 23// ___3_______ _13_____ 24// / \ / \ 25// 1_ _____8____ 12 _15__ 26// \ / \ / \ 27// 2 4_ _10 14 16 28// \ / 29// 5_ 9 30// \ 31// 7 32 33const objBST = new BST<number, { height: number, age: number }>(); 34 35objBST.add(11, { "name": "Pablo", "age": 15 }); 36objBST.add(3, { "name": "Kirk", "age": 1 }); 37 38objBST.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], [ 39 { "name": "Alice", "age": 15 }, 40 { "name": "Bob", "age": 1 }, 41 { "name": "Charlie", "age": 8 }, 42 { "name": "David", "age": 13 }, 43 { "name": "Emma", "age": 16 }, 44 { "name": "Frank", "age": 2 }, 45 { "name": "Grace", "age": 6 }, 46 { "name": "Hannah", "age": 9 }, 47 { "name": "Isaac", "age": 12 }, 48 { "name": "Jack", "age": 14 }, 49 { "name": "Katie", "age": 4 }, 50 { "name": "Liam", "age": 7 }, 51 { "name": "Mia", "age": 10 }, 52 { "name": "Noah", "age": 5 } 53 ] 54); 55 56objBST.delete(11);
1import { AVLTree } from '@hoangcung1804npm/voluptatum-earum-temporibus'; 2 3const avlTree = new AVLTree<number>(); 4avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]) 5avlTree.isAVLBalanced(); // true 6avlTree.delete(10); 7avlTree.isAVLBalanced(); // true
1import { DirectedGraph } from '@hoangcung1804npm/voluptatum-earum-temporibus'; 2 3const graph = new DirectedGraph<string>(); 4 5graph.addVertex('A'); 6graph.addVertex('B'); 7 8graph.hasVertex('A'); // true 9graph.hasVertex('B'); // true 10graph.hasVertex('C'); // false 11 12graph.addEdge('A', 'B'); 13graph.hasEdge('A', 'B'); // true 14graph.hasEdge('B', 'A'); // false 15 16graph.deleteEdgeSrcToDest('A', 'B'); 17graph.hasEdge('A', 'B'); // false 18 19graph.addVertex('C'); 20 21graph.addEdge('A', 'B'); 22graph.addEdge('B', 'C'); 23 24const topologicalOrderKeys = graph.topologicalSort(); // ['A', 'B', 'C']
1import { UndirectedGraph } from '@hoangcung1804npm/voluptatum-earum-temporibus'; 2 3const graph = new UndirectedGraph<string>(); 4graph.addVertex('A'); 5graph.addVertex('B'); 6graph.addVertex('C'); 7graph.addVertex('D'); 8graph.deleteVertex('C'); 9graph.addEdge('A', 'B'); 10graph.addEdge('B', 'D'); 11 12const dijkstraResult = graph.dijkstra('A'); 13Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key) // ['A', 'B', 'D'] 14 15
MacBook Pro (15-inch, 2018)
Processor 2.2 GHz 6-Core Intel Core i7
Memory 16 GB 2400 MHz DDR4
Graphics Radeon Pro 555X 4 GB
Intel UHD Graphics 630 1536 MB
macOS Big Sur
Version 11.7.9
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add | 6.09 | 164.12 | 1.35e-4 |
| 100,000 add & poll | 34.55 | 28.94 | 6.43e-4 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add | 76.73 | 13.03 | 0.00 |
| 100,000 add randomly | 80.67 | 12.40 | 0.00 |
| 100,000 get | 110.86 | 9.02 | 0.00 |
| 100,000 iterator | 24.99 | 40.02 | 0.00 |
| 100,000 add & delete orderly | 152.66 | 6.55 | 0.00 |
| 100,000 add & delete randomly | 230.75 | 4.33 | 0.00 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 39.27 | 25.46 | 0.01 |
| 100,000 push & shift | 4.53 | 220.81 | 4.84e-4 |
| Native JS Array 100,000 push & shift | 1948.05 | 0.51 | 0.02 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 23.22 | 43.06 | 0.00 |
| 1,000,000 push & pop | 29.68 | 33.69 | 0.00 |
| 1,000,000 push & shift | 29.33 | 34.09 | 0.00 |
| 100,000 push & shift | 3.10 | 323.01 | 2.47e-4 |
| Native JS Array 100,000 push & shift | 1942.12 | 0.51 | 0.02 |
| 100,000 unshift & shift | 2.77 | 360.50 | 2.43e-4 |
| Native JS Array 100,000 unshift & shift | 3835.21 | 0.26 | 0.03 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 set | 112.38 | 8.90 | 0.02 |
| Native JS Map 1,000,000 set | 199.97 | 5.00 | 0.01 |
| Native JS Set 1,000,000 add | 163.34 | 6.12 | 0.01 |
| 1,000,000 set & get | 109.86 | 9.10 | 0.02 |
| Native JS Map 1,000,000 set & get | 255.33 | 3.92 | 0.00 |
| Native JS Set 1,000,000 add & has | 163.91 | 6.10 | 0.00 |
| 1,000,000 ObjKey set & get | 317.89 | 3.15 | 0.04 |
| Native JS Map 1,000,000 ObjKey set & get | 282.99 | 3.53 | 0.03 |
| Native JS Set 1,000,000 ObjKey add & has | 253.93 | 3.94 | 0.03 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 push | 43.71 | 22.88 | 7.33e-4 |
| 100,000 getWords | 83.63 | 11.96 | 0.00 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add | 271.93 | 3.68 | 0.01 |
| 100,000 add randomly | 318.27 | 3.14 | 0.00 |
| 100,000 get | 128.85 | 7.76 | 0.00 |
| 100,000 iterator | 29.09 | 34.38 | 0.00 |
| 100,000 add & delete orderly | 435.48 | 2.30 | 7.44e-4 |
| 100,000 add & delete randomly | 578.70 | 1.73 | 0.00 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 10,000 RBTree add randomly | 6.69 | 149.54 | 1.06e-4 |
| 10,000 RBTree get randomly | 9.19 | 108.82 | 1.43e-4 |
| 10,000 RBTree add & delete randomly | 18.54 | 53.94 | 1.73e-4 |
| 10,000 AVLTree add randomly | 23.70 | 42.20 | 1.88e-4 |
| 10,000 AVLTree get randomly | 9.89 | 101.11 | 0.00 |
| 10,000 AVLTree add & delete randomly | 44.44 | 22.50 | 4.30e-4 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000 addVertex | 0.10 | 9766.65 | 9.83e-7 |
| 1,000 addEdge | 6.15 | 162.57 | 7.99e-4 |
| 1,000 getVertex | 0.05 | 2.18e+4 | 4.52e-7 |
| 1,000 getEdge | 22.70 | 44.06 | 0.00 |
| tarjan | 203.00 | 4.93 | 0.01 |
| topologicalSort | 176.40 | 5.67 | 0.00 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 222.02 | 4.50 | 0.07 |
| 1,000,000 unshift | 220.41 | 4.54 | 0.05 |
| 1,000,000 unshift & shift | 185.31 | 5.40 | 0.01 |
| 1,000,000 addBefore | 317.20 | 3.15 | 0.07 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push & shift | 204.82 | 4.88 | 0.09 |
| 10,000 push & pop | 221.88 | 4.51 | 0.03 |
| 10,000 addBefore | 247.28 | 4.04 | 0.01 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add | 26.97 | 37.08 | 7.97e-4 |
| 100,000 add & poll | 74.55 | 13.41 | 5.19e-4 |
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 35.54 | 28.14 | 0.00 |
| 1,000,000 push & pop | 44.89 | 22.27 | 0.01 |
| Data Structure Typed | C++ STL | java.util | Python collections |
|---|---|---|---|
| Heap<E> | - | - | heapq |
| PriorityQueue<E> | priority_queue<T> | PriorityQueue<E> | - |
| Deque<E> | deque<T> | ArrayDeque<E> | deque |
| Queue<E> | queue<T> | Queue<E> | - |
| HashMap<K, V> | unordered_map<K, V> | HashMap<K, V> | defaultdict |
| DoublyLinkedList<E> | list<T> | LinkedList<E> | - |
| SinglyLinkedList<E> | - | - | - |
| BinaryTree<K, V> | - | - | - |
| BST<K, V> | - | - | - |
| RedBlackTree<E> | set<T> | TreeSet<E> | - |
| RedBlackTree<K, V> | map<K, V> | TreeMap<K, V> | - |
| TreeMultiMap<K, V> | multimap<K, V> | - | - |
| TreeMultiMap<E> | multiset<T> | - | - |
| Trie | - | - | - |
| DirectedGraph<V, E> | - | - | - |
| UndirectedGraph<V, E> | - | - | - |
| PriorityQueue<E> | priority_queue<T> | PriorityQueue<E> | - |
| Array<E> | vector<T> | ArrayList<E> | list |
| Stack<E> | stack<T> | Stack<E> | - |
| HashMap<E> | unordered_set<T> | HashSet<E> | set |
| - | unordered_multiset | - | Counter |
| LinkedHashMap<K, V> | - | LinkedHashMap<K, V> | OrderedDict |
| - | unordered_multimap<K, V> | - | - |
| - | bitset<N> | - | - |
| Algorithm | Function Description | Iteration Type |
|---|---|---|
| Binary Tree DFS | Traverse a binary tree in a depth-first manner, starting from the root node, first visiting the left subtree, and then the right subtree, using recursion. | Recursion + Iteration |
| Binary Tree BFS | Traverse a binary tree in a breadth-first manner, starting from the root node, visiting nodes level by level from left to right. | Iteration |
| Graph DFS | Traverse a graph in a depth-first manner, starting from a given node, exploring along one path as deeply as possible, and backtracking to explore other paths. Used for finding connected components, paths, etc. | Recursion + Iteration |
| Binary Tree Morris | Morris traversal is an in-order traversal algorithm for binary trees with O(1) space complexity. It allows tree traversal without additional stack or recursion. | Iteration |
| Graph BFS | Traverse a graph in a breadth-first manner, starting from a given node, first visiting nodes directly connected to the starting node, and then expanding level by level. Used for finding shortest paths, etc. | Recursion + Iteration |
| Graph Tarjan's Algorithm | Find strongly connected components in a graph, typically implemented using depth-first search. | Recursion |
| Graph Bellman-Ford Algorithm | Finding the shortest paths from a single source, can handle negative weight edges | Iteration |
| Graph Dijkstra's Algorithm | Finding the shortest paths from a single source, cannot handle negative weight edges | Iteration |
| Graph Floyd-Warshall Algorithm | Finding the shortest paths between all pairs of nodes | Iteration |
| Graph getCycles | Find all cycles in a graph or detect the presence of cycles. | Recursion |
| Graph getCutVertices | Find cut vertices in a graph, which are nodes that, when removed, increase the number of connected components in the graph. | Recursion |
| Graph getSCCs | Find strongly connected components in a graph, which are subgraphs where any two nodes can reach each other. | Recursion |
| Graph getBridges | Find bridges in a graph, which are edges that, when removed, increase the number of connected components in the graph. | Recursion |
| Graph topologicalSort | Perform topological sorting on a directed acyclic graph (DAG) to find a linear order of nodes such that all directed edges go from earlier nodes to later nodes. | Recursion |
We strictly adhere to computer science theory and software development standards. Our LinkedList is designed in the traditional sense of the LinkedList data structure, and we refrain from substituting it with a Deque solely for the purpose of showcasing performance test data. However, we have also implemented a Deque based on a dynamic array concurrently.
| Principle | Description |
|---|---|
| Practicality | Follows ES6 and ESNext standards, offering unified and considerate optional parameters, and simplifies method names. |
| Extensibility | Adheres to OOP (Object-Oriented Programming) principles, allowing inheritance for all data structures. |
| Modularization | Includes data structure modularization and independent NPM packages. |
| Efficiency | All methods provide time and space complexity, comparable to native JS performance. |
| Maintainability | Follows open-source community development standards, complete documentation, continuous integration, and adheres to TDD (Test-Driven Development) patterns. |
| Testability | Automated and customized unit testing, performance testing, and integration testing. |
| Portability | Plans for porting to Java, Python, and C++, currently achieved to 80%. |
| Reusability | Fully decoupled, minimized side effects, and adheres to OOP. |
| Security | Carefully designed security for member variables and methods. Read-write separation. Data structure software does not need to consider other security aspects. |
| Scalability | Data structure software does not involve load issues. |
Now you can use it in Node.js and browser environments
CommonJS:require export.modules =
ESModule: import export
Typescript: import export
UMD: var Deque = dataStructureTyped.Deque
Copy the line below into the head tag in an HTML document.
1 2<script src='https://cdn.jsdelivr.net/npm/@hoangcung1804npm/voluptatum-earum-temporibus/dist/umd/@hoangcung1804npm/voluptatum-earum-temporibus.js'></script>
1 2<script src='https://cdn.jsdelivr.net/npm/@hoangcung1804npm/voluptatum-earum-temporibus/dist/umd/@hoangcung1804npm/voluptatum-earum-temporibus.min.js'></script>
Copy the code below into the script tag of your HTML, and you're good to go with your development.
1const { Heap } = dataStructureTyped; 2const { 3 BinaryTree, Graph, Queue, Stack, PriorityQueue, BST, Trie, DoublyLinkedList, 4 AVLTree, MinHeap, SinglyLinkedList, DirectedGraph, TreeMultiMap, 5 DirectedVertex, AVLTreeNode 6} = dataStructureTyped;
No vulnerabilities found.
No security vulnerabilities found.
