data-structure-typed
English | 简体中文
Why
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 data-structure-typed.Benchmark
compared with C++ STL. API standards
aligned with ES6 and Java. Usability
is comparable to Python
We provide data structures that are not available in JS/TS
Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, Directed Graph, Undirected Graph, BST, AVL Tree, Priority Queue, Queue, Tree Multiset, Linked List.
Performance surpasses that of native JS/TS
Method
Time Taken (ms)
Scale
Belongs To
Queue.push & shift
5.83
100,000
data-structure-typed
Array.push & shift
2829.59
100,000
Native JS
Deque.unshift & shift
2.44
100,000
data-structure-typed
Array.unshift & shift
4750.37
100,000
Native JS
HashMap.set
122.51
1,000,000
data-structure-typed
Map.set
223.80
1,000,000
Native JS
Set.add
185.06
1,000,000
Native JS
Installation and Usage
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
npm
npm i data-structure-typed --save
yarn
yarn add data-structure-typed
import {
BinaryTree , Graph , Queue , Stack , PriorityQueue , BST , Trie , DoublyLinkedList ,
AVLTree , MinHeap , SinglyLinkedList , DirectedGraph , TreeMultimap ,
DirectedVertex , AVLTreeNode
} from 'data-structure-typed' ;
CDN
Copy the line below into the head tag in an HTML document.
development
< script src = 'https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.js' ></ script >
production
< script src = 'https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js' ></ script >
Copy the code below into the script tag of your HTML, and you're good to go with your development.
const { Heap } = dataStructureTyped ;
const {
BinaryTree , Graph , Queue , Stack , PriorityQueue , BST , Trie , DoublyLinkedList ,
AVLTree , MinHeap , SinglyLinkedList , DirectedGraph , TreeMultimap ,
DirectedVertex , AVLTreeNode
} = dataStructureTyped ;
Vivid Examples
Binary Tree
Try it out , or you can run your own code using
our visual tool
Binary Tree DFS
Try it out
AVL Tree
Try it out
Tree Multi Map
Try it out
Matrix
Try it out
Directed Graph
Try it out
Map Graph
Try it out
Code Snippets
Binary Search Tree (BST) snippet
TS
import { BST , BSTNode } from 'data-structure-typed' ;
const bst = new BST < number >();
bst . add ( 11 );
bst . add ( 3 );
bst . addMany ([ 15 , 1 , 8 , 13 , 16 , 2 , 6 , 9 , 12 , 14 , 4 , 7 , 10 , 5 ]);
bst . size === 16 ; // true
bst . has ( 6 ); // true
const node6 = bst . getNode ( 6 ); // BSTNode
bst . getHeight ( 6 ) === 2 ; // true
bst . getHeight () === 5 ; // true
bst . getDepth ( 6 ) === 3 ; // true
bst . getLeftMost () ? . key === 1 ; // true
bst . delete ( 6 );
bst . get ( 6 ); // undefined
bst . isAVLBalanced (); // true
bst . bfs ()[ 0 ] === 11 ; // true
bst . print ()
// ______________11_____
// / \
// ___3_______ _13_____
// / \ / \
// 1_ _____8____ 12 _15__
// \ / \ / \
// 2 4_ _10 14 16
// \ /
// 5_ 9
// \
// 7
const objBST = new BST < number , { height : number , age : number }>();
objBST . add ( 11 , { "name" : "Pablo" , "age" : 15 });
objBST . add ( 3 , { "name" : "Kirk" , "age" : 1 });
objBST . addMany ([ 15 , 1 , 8 , 13 , 16 , 2 , 6 , 9 , 12 , 14 , 4 , 7 , 10 , 5 ], [
{ "name" : "Alice" , "age" : 15 },
{ "name" : "Bob" , "age" : 1 },
{ "name" : "Charlie" , "age" : 8 },
{ "name" : "David" , "age" : 13 },
{ "name" : "Emma" , "age" : 16 },
{ "name" : "Frank" , "age" : 2 },
{ "name" : "Grace" , "age" : 6 },
{ "name" : "Hannah" , "age" : 9 },
{ "name" : "Isaac" , "age" : 12 },
{ "name" : "Jack" , "age" : 14 },
{ "name" : "Katie" , "age" : 4 },
{ "name" : "Liam" , "age" : 7 },
{ "name" : "Mia" , "age" : 10 },
{ "name" : "Noah" , "age" : 5 }
]
);
objBST . delete ( 11 );
JS
const { BST , BSTNode } = require ( 'data-structure-typed' );
const bst = new BST ();
bst . add ( 11 );
bst . add ( 3 );
bst . addMany ([ 15 , 1 , 8 , 13 , 16 , 2 , 6 , 9 , 12 , 14 , 4 , 7 , 10 , 5 ]);
bst . size === 16 ; // true
bst . has ( 6 ); // true
const node6 = bst . getNode ( 6 );
bst . getHeight ( 6 ) === 2 ; // true
bst . getHeight () === 5 ; // true
bst . getDepth ( 6 ) === 3 ; // true
const leftMost = bst . getLeftMost ();
leftMost ? . key === 1 ; // true
bst . delete ( 6 );
bst . get ( 6 ); // undefined
bst . isAVLBalanced (); // true or false
const bfsIDs = bst . bfs ();
bfsIDs [ 0 ] === 11 ; // true
AVLTree snippet
import { AVLTree } from 'data-structure-typed' ;
const avlTree = new AVLTree < number >();
avlTree . addMany ([ 11 , 3 , 15 , 1 , 8 , 13 , 16 , 2 , 6 , 9 , 12 , 14 , 4 , 7 , 10 , 5 ])
avlTree . isAVLBalanced (); // true
avlTree . delete ( 10 );
avlTree . isAVLBalanced (); // true
RedBlackTree snippet
import { RedBlackTree } from 'data-structure-typed' ;
const rbTree = new RedBlackTree < number >();
rbTree . addMany ([ 11 , 3 , 15 , 1 , 8 , 13 , 16 , 2 , 6 , 9 , 12 , 14 , 4 , 7 , 10 , 5 ])
rbTree . isAVLBalanced (); // true
rbTree . delete ( 10 );
rbTree . isAVLBalanced (); // true
rbTree . print ()
// ___6________
// / \
// ___4_ ___11________
// / \ / \
// _2_ 5 _8_ ____14__
// / \ / \ / \
// 1 3 7 9 12__ 15__
// \ \
// 13 16
Directed Graph simple snippet
import { DirectedGraph } from 'data-structure-typed' ;
const graph = new DirectedGraph < string >();
graph . addVertex ( 'A' );
graph . addVertex ( 'B' );
graph . hasVertex ( 'A' ); // true
graph . hasVertex ( 'B' ); // true
graph . hasVertex ( 'C' ); // false
graph . addEdge ( 'A' , 'B' );
graph . hasEdge ( 'A' , 'B' ); // true
graph . hasEdge ( 'B' , 'A' ); // false
graph . deleteEdgeSrcToDest ( 'A' , 'B' );
graph . hasEdge ( 'A' , 'B' ); // false
graph . addVertex ( 'C' );
graph . addEdge ( 'A' , 'B' );
graph . addEdge ( 'B' , 'C' );
const topologicalOrderKeys = graph . topologicalSort (); // ['A', 'B', 'C']
Undirected Graph snippet
import { UndirectedGraph } from 'data-structure-typed' ;
const graph = new UndirectedGraph < string >();
graph . addVertex ( 'A' );
graph . addVertex ( 'B' );
graph . addVertex ( 'C' );
graph . addVertex ( 'D' );
graph . deleteVertex ( 'C' );
graph . addEdge ( 'A' , 'B' );
graph . addEdge ( 'B' , 'D' );
const dijkstraResult = graph . dijkstra ( 'A' );
Array . from ( dijkstraResult ? . seen ?? []). map ( vertex => vertex . key ) // ['A', 'B', 'D']
Free conversion between data structures.
const orgArr = [ 6 , 1 , 2 , 7 , 5 , 3 , 4 , 9 , 8 ];
const orgStrArr = [ "trie" , "trial" , "trick" , "trip" , "tree" , "trend" , "triangle" , "track" , "trace" , "transmit" ];
const entries = [[ 6 , 6 ], [ 1 , 1 ], [ 2 , 2 ], [ 7 , 7 ], [ 5 , 5 ], [ 3 , 3 ], [ 4 , 4 ], [ 9 , 9 ], [ 8 , 8 ]];
const queue = new Queue ( orgArr );
queue . print ();
// [6, 1, 2, 7, 5, 3, 4, 9, 8]
const deque = new Deque ( orgArr );
deque . print ();
// [6, 1, 2, 7, 5, 3, 4, 9, 8]
const sList = new SinglyLinkedList ( orgArr );
sList . print ();
// [6, 1, 2, 7, 5, 3, 4, 9, 8]
const dList = new DoublyLinkedList ( orgArr );
dList . print ();
// [6, 1, 2, 7, 5, 3, 4, 9, 8]
const stack = new Stack ( orgArr );
stack . print ();
// [6, 1, 2, 7, 5, 3, 4, 9, 8]
const minHeap = new MinHeap ( orgArr );
minHeap . print ();
// [1, 5, 2, 7, 6, 3, 4, 9, 8]
const maxPQ = new MaxPriorityQueue ( orgArr );
maxPQ . print ();
// [9, 8, 4, 7, 5, 2, 3, 1, 6]
const biTree = new BinaryTree ( entries );
biTree . print ();
// ___6___
// / \
// ___1_ _2_
// / \ / \
// _7_ 5 3 4
// / \
// 9 8
const bst = new BST ( entries );
bst . print ();
// _____5___
// / \
// _2_ _7_
// / \ / \
// 1 3_ 6 8_
// \ \
// 4 9
const rbTree = new RedBlackTree ( entries );
rbTree . print ();
// ___4___
// / \
// _2_ _6___
// / \ / \
// 1 3 5 _8_
// / \
// 7 9
const avl = new AVLTree ( entries );
avl . print ();
// ___4___
// / \
// _2_ _6___
// / \ / \
// 1 3 5 _8_
// / \
// 7 9
const treeMulti = new TreeMultimap ( entries );
treeMulti . print ();
// ___4___
// / \
// _2_ _6___
// / \ / \
// 1 3 5 _8_
// / \
// 7 9
const hm = new HashMap ( entries );
hm . print ()
// [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]]
const rbTreeH = new RedBlackTree ( hm );
rbTreeH . print ();
// ___4___
// / \
// _2_ _6___
// / \ / \
// 1 3 5 _8_
// / \
// 7 9
const pq = new MinPriorityQueue ( orgArr );
pq . print ();
// [1, 5, 2, 7, 6, 3, 4, 9, 8]
const bst1 = new BST ( pq );
bst1 . print ();
// _____5___
// / \
// _2_ _7_
// / \ / \
// 1 3_ 6 8_
// \ \
// 4 9
const dq1 = new Deque ( orgArr );
dq1 . print ();
// [6, 1, 2, 7, 5, 3, 4, 9, 8]
const rbTree1 = new RedBlackTree ( dq1 );
rbTree1 . print ();
// _____5___
// / \
// _2___ _7___
// / \ / \
// 1 _4 6 _9
// / /
// 3 8
const trie2 = new Trie ( orgStrArr );
trie2 . print ();
// ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
const heap2 = new Heap ( trie2 , { comparator : ( a , b ) => Number ( a ) - Number ( b ) });
heap2 . print ();
// ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
const dq2 = new Deque ( heap2 );
dq2 . print ();
// ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
const entries2 = dq2 . map (( el , i ) => [ i , el ]);
const avl2 = new AVLTree ( entries2 );
avl2 . print ();
// ___3_______
// / \
// _1_ ___7_
// / \ / \
// 0 2 _5_ 8_
// / \ \
// 4 6 9
API docs & Examples
API Docs
Live Examples
Examples Repository
Data Structures
Data Structure
Unit Test
Performance Test
API Docs
Binary Tree
View
Binary Search Tree (BST)
View
AVL Tree
View
Red Black Tree
View
Tree Multimap
View
Heap
View
Priority Queue
View
Max Priority Queue
View
Min Priority Queue
View
Trie
View
Graph
View
Directed Graph
View
Undirected Graph
View
Queue
View
Deque
View
Hash Map
View
Linked List
View
Singly Linked List
View
Doubly Linked List
View
Stack
View
Segment Tree
View
Binary Indexed Tree
View
Standard library data structure comparison
Data Structure Typed
C++ STL
java.util
Python collections
Heap<E>
priority_queue<T>
PriorityQueue<E>
heapq
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>
-
-
Built-in classic algorithms
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 getCutVertexes
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
Software Engineering Design Standards
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.
Benchmark
avl-tree
test name time taken (ms) executions per sec sample deviation 10,000 add randomly 51.22 19.52 0.00 10,000 add & delete randomly 110.40 9.06 0.00 10,000 addMany 58.39 17.13 6.35e-4 10,000 get 50.59 19.77 3.87e-4
binary-tree
test name time taken (ms) executions per sec sample deviation 1,000 add randomly 13.83 72.29 1.19e-4 1,000 add & delete randomly 21.49 46.54 2.34e-4 1,000 addMany 15.93 62.78 1.27e-4 1,000 get 18.19 54.98 1.79e-4 1,000 has 18.20 54.93 1.71e-4 1,000 dfs 161.79 6.18 7.45e-4 1,000 bfs 56.68 17.64 4.77e-4 1,000 morris 262.64 3.81 0.00
bst
test name time taken (ms) executions per sec sample deviation 10,000 add randomly 51.51 19.41 8.70e-4 10,000 add & delete randomly 114.09 8.76 9.66e-4 10,000 addMany 47.86 20.90 2.77e-4 10,000 get 51.93 19.26 6.56e-4
rb-tree
test name time taken (ms) executions per sec sample deviation 100,000 add 86.63 11.54 0.00 100,000 add & delete randomly 218.88 4.57 0.01 100,000 getNode 261.16 3.83 0.00 100,000 add & iterator 117.64 8.50 0.00
comparison
test name time taken (ms) executions per sec sample deviation SRC PQ 10,000 add 0.14 6949.20 1.53e-6 CJS PQ 10,000 add 0.14 6943.68 1.74e-6 MJS PQ 10,000 add 0.57 1758.40 6.26e-6 SRC PQ 10,000 add & pop 3.40 293.94 3.50e-5 CJS PQ 10,000 add & pop 3.42 292.69 5.34e-5 MJS PQ 10,000 add & pop 3.30 303.01 3.97e-5
directed-graph
test name time taken (ms) executions per sec sample deviation 1,000 addVertex 0.10 9930.74 1.11e-6 1,000 addEdge 6.13 163.19 1.84e-4 1,000 getVertex 0.05 2.15e+4 5.00e-7 1,000 getEdge 23.57 42.43 0.00 tarjan 252.05 3.97 0.03 tarjan all 221.15 4.52 0.00 topologicalSort 181.07 5.52 0.00
hash-map
test name time taken (ms) executions per sec sample deviation 1,000,000 set 122.90 8.14 0.04 Native Map 1,000,000 set 215.97 4.63 0.02 Native Set 1,000,000 add 179.11 5.58 0.02 1,000,000 set & get 123.10 8.12 0.04 Native Map 1,000,000 set & get 271.80 3.68 0.02 Native Set 1,000,000 add & has 176.65 5.66 0.02 1,000,000 ObjKey set & get 341.97 2.92 0.07 Native Map 1,000,000 ObjKey set & get 316.86 3.16 0.04 Native Set 1,000,000 ObjKey add & has 285.14 3.51 0.06
heap
test name time taken (ms) executions per sec sample deviation 100,000 add & pop 80.37 12.44 0.00 100,000 add & dfs 36.20 27.63 0.00 10,000 fib add & pop 362.24 2.76 0.00
doubly-linked-list
test name time taken (ms) executions per sec sample deviation 1,000,000 push 216.09 4.63 0.06 1,000,000 unshift 220.68 4.53 0.02 1,000,000 unshift & shift 172.93 5.78 0.04 1,000,000 insertBefore 332.25 3.01 0.08
singly-linked-list
test name time taken (ms) executions per sec sample deviation 1,000,000 push & shift 222.99 4.48 0.10 10,000 push & pop 214.82 4.66 0.01 10,000 insertBefore 251.24 3.98 0.01
max-priority-queue
test name time taken (ms) executions per sec sample deviation 10,000 refill & poll 8.91 112.19 1.57e-4
priority-queue
test name time taken (ms) executions per sec sample deviation 100,000 add & pop 101.70 9.83 0.00
deque
test name time taken (ms) executions per sec sample deviation 1,000,000 push 13.80 72.47 1.56e-4 1,000,000 push & pop 22.72 44.02 2.02e-4 100,000 push & shift 2.35 425.67 5.80e-5 Native Array 100,000 push & shift 2511.14 0.40 0.36 100,000 unshift & shift 2.23 447.89 3.30e-4 Native Array 100,000 unshift & shift 4140.23 0.24 0.33
queue
test name time taken (ms) executions per sec sample deviation 1,000,000 push 43.65 22.91 0.01 100,000 push & shift 4.99 200.28 9.54e-5 Native Array 100,000 push & shift 2335.63 0.43 0.33 Native Array 100,000 push & pop 4.39 227.81 0.00
stack
test name time taken (ms) executions per sec sample deviation 1,000,000 push 45.38 22.04 0.01 1,000,000 push & pop 49.52 20.19 0.01
trie
test name time taken (ms) executions per sec sample deviation 100,000 push 42.99 23.26 0.00 100,000 getWords 89.78 11.14 0.00