mirror of
https://github.com/zrwusa/data-structure-typed.git
synced 2024-11-27 06:24:05 +00:00
52 KiB
52 KiB
data-structure-typed
为什么
JavaScript和TypeScript的数据结构。
是否羡慕C++ STL (std::)、Python的 collections 和Java的 java.util？
不再需要羡慕了！JavaScript和TypeScript现在拥有 data-structure-typed。
基准测试 与C++ STL相比。API 标准 与ES6和Java对齐。易用性 可与Python媲美。
提供了JS/TS中没有的数据结构
Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, Directed Graph, Undirected Graph, BST, AVL Tree, Priority Queue, Queue, Tree Multiset.
性能超越原生JS/TS
| 方法名 | 耗时（毫秒） | 数据规模 | 所属标准库 |
|---|---|---|---|
| Queue.push & shift | 5.83 | 100,000 | data-structure-typed |
| Array.push & shift | 2829.59 | 100,000 | 原生JS |
| Deque.unshift & shift | 2.44 | 100,000 | data-structure-typed |
| Array.unshift & shift | 4750.37 | 100,000 | 原生JS |
| HashMap.set | 122.51 | 1,000,000 | data-structure-typed |
| Map.set | 223.80 | 1,000,000 | 原生JS |
| Set.add | 185.06 | 1,000,000 | 原生JS |
安装和使用
现在你可以在 Node.js 和浏览器环境中使用它
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
将下面的代码复制到 HTML 文档的头标签中。
开发环境
<script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.js'></script>
生产环境
<script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>
将下面的代码复制到你的 HTML 的 script 标签中，你就可以开始你的开发了。
const { Heap } = dataStructureTyped;
const {
BinaryTree, Graph, Queue, Stack, PriorityQueue, BST, Trie, DoublyLinkedList,
AVLTree, MinHeap, SinglyLinkedList, DirectedGraph, TreeMultiMap,
DirectedVertex, AVLTreeNode
} = dataStructureTyped;
生动示例
Binary Tree（二叉树）
试一下 ，或者你可以使用我们的可视化工具运行自己的代码 visual tool
Binary Tree DFS （二叉搜索树深度遍历）
AVL Tree（AVL树）
Tree Multi Map
Matrix
有向图
地图
代码片段
红黑树 代码示例
TS
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
JS
import { RedBlackTree } from 'data-structure-typed';
const rbTree = new RedBlackTree();
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
二叉搜索树 (BST) 代码示例
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);
AVL树 代码示例
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
有向图代码示例
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']
无向图代码示例
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']
不同数据结构之间互相转换
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 文档 & 演示
包含的数据结构
| 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 |
形象比喻与选型
| 分类 | 数据结构 | 选型原因 | 大白话描述 | 图示 |
|---|---|---|---|---|
| 线性结构 | Array | 需要快速随机访问，固定大小，元素类型相同 | 一排编号的兔子。如果你想找到名叫Pablo的兔子，你可以直接喊出Pablo的号码0680（通过数组索引直接找到元素，时间复杂度O(1)）。但是，如果你不知道Pablo的号码，你仍然需要逐个搜索（时间复杂度O(n)）。此外，如果你想在Pablo后面添加一只名叫Vicky的兔子，你需要重新为Vicky之后的所有兔子编号（时间复杂度O(n)）。 | 
|
| Linked List | 需要频繁插入删除，大小可变 | 一排兔子，每只兔子抓着前面兔子的尾巴（每只兔子只知道它后面兔子的名字）。你想找一只名叫Pablo的兔子，你必须从第一只兔子开始搜索。如果不是Pablo，你就继续顺着那只兔子的尾巴找下一只。所以，你可能需要搜索n次才能找到Pablo（时间复杂度O(n)）。如果你想在Pablo和Vicky之间插入一只名叫Remi的兔子，这很简单。你只需让Vicky放开Pablo的尾巴，让Remi抓住Pablo的尾巴，然后让Vicky抓住Remi的尾巴（时间复杂度O(1)）。 | 
|
|
| Singly Linked List | 只需要单向遍历，内存占用较少 | 与链表描述相同。 |
|
|
| Doubly Linked List | 需要双向遍历，允许从尾部快速删除 | 一排兔子，每只兔子抓着前面兔子的尾巴（每只兔子知道相邻两只兔子的名字）。这为单向链表提供了向前搜索的能力，仅此而已。例如，如果你直接来到队列中的Remi兔子那里，问她Vicky在哪里，她会说在我后面抓着我尾巴的那只，如果你问她Pablo在哪里，她会说就在前面。 | 
|
|
| Queue | 需要先进先出（FIFO）的处理顺序 | 一排编号的兔子，第一只兔子身上贴着便利贴。对于这个贴有便利贴的队列，每当我们想从队列前面移除一只兔子时，我们只需要将便利贴移到下一只兔子的脸上，而不需要实际移除兔子，以避免重新为后面所有的兔子编号（从前面移除也是O(1)时间复杂度）。对于队列尾部，我们不需要担心，因为每只新添加到尾部的兔子直接被赋予一个新编号（O(1)时间复杂度），不需要重新为之前所有的兔子编号。 | 
|
|
| Deque | 需要在两端都能快速插入和删除 | 一排分组编号的兔子，第一只兔子身上贴着便利贴。对于这个队列，我们按组管理。每次从队列前面移除一只兔子时，我们只将便利贴移到下一只兔子身上。这样，我们不需要每次移除第一只兔子时都重新为后面所有的兔子编号。只有当一个组的所有成员都被移除时，我们才重新分配编号和分组。尾部的处理也是类似的。这是一种延迟和批量操作的策略，以抵消数组数据结构在中间插入或删除元素时需要移动所有后续元素的缺点。 | 
|
|
| Stack | 需要后进先出（LIFO）的处理顺序 | 一排兔子在一个死胡同隧道里，兔子只能从隧道入口（末端）被移除，新兔子也只能从入口（末端）被添加。 | 
|
|
| 树结构 | Binary Tree | 需要层次结构，每个节点最多有两个子节点 | 顾名思义，它是一棵每个节点最多有两个子节点的树。当你添加连续的数据如[4, 2, 6, 1, 3, 5, 7]时，它将是一个完全二叉树。当你添加像[4, 2, 6, null, 1, 3, null, 5, null, 7]这样的数据时，你可以指定任何左或右子节点是否为空，树的形状是完全可控的。 | 
|
| Binary Search Tree | 需要快速查找、插入和删除，但不要求严格平衡 | 一个由双向链表组成的树状兔子群落，每只兔子最多有两条尾巴。这些兔子有纪律且听话，按照一定的顺序排列在自己的位置上。二叉树中最重要的数据结构（核心是插入、删除、修改、查找的时间复杂度为O(log n)）。BST中存储的数据是结构化和有序的，不是严格的1、2、3、4、5这样的顺序，而是保持左子树中的所有节点小于节点，右子树中的所有节点大于节点。这种顺序为插入、删除、修改和搜索提供了O(log n)的时间复杂度。将O(n)降低到O(log n)是计算机领域最常见的算法复杂度优化，效率提升是指数级的。它也是将无序数据组织成有序数据的最有效方式（大多数排序算法只能保持O(n log n)）。当然，我们提供的二叉搜索树支持以升序和降序组织数据。请记住，基本的BST没有自平衡能力，如果你顺序添加已排序的数据到这个数据结构中，它将退化成一个列表，从而失去O(log n)的能力。当然，我们的addMany方法经过特殊处理以防止退化。但是，对于实际应用，请尽可能使用红黑树或AVL树，因为它们天生就具有自平衡功能。 | 
|
|
| Red Black Tree | 需要自平衡的二叉搜索树，保证最坏情况下的性能 | 一个由双向链表组成的树状兔子群落，每只兔子最多有两条尾巴。这些兔子不仅听话，而且聪明，会自动按照一定的顺序排列自己的位置。一种自平衡的二叉搜索树。每个节点都标有红黑标记。确保没有任何路径比其他路径长两倍以上（保持一定的平衡以提高搜索、添加和删除的速度）。 | ||
| AVL Tree | 需要严格平衡的二叉搜索树，读取操作频繁 | 一个由双向链表组成的树状兔子群落，每只兔子最多有两条尾巴。这些兔子不仅听话和聪明，会自动按照一定的顺序排列自己的位置，而且遵循非常严格的规则。一种自平衡的二叉搜索树。每个节点都标有平衡因子，表示其左右子树的高度差。平衡因子的绝对值不超过1（保持更严格的平衡，使得搜索效率高于红黑树，但插入和删除操作会更复杂，相对效率较低）。 | 
|
|
| Trie | 需要高效地存储和搜索字符串，特别是前缀匹配 | 一种特殊的树结构，用于高效存储和检索字符串数据集中的键。这种结构特别适用于实现字典和支持前缀搜索。 | （图示暂缺） | |
| 堆 | Heap | 需要快速获取最大或最小元素 | 一种特殊的完全二叉树，通常存储在数组中，其中索引为i的节点的子节点位于索引2i+1和2i+2处。自然地，任何节点的父节点位于⌊(i−1)/2⌋处。 | 
|
| Priority Queue | 需要按优先级处理元素 | 实际上就是一个堆。 |
|
|
| 图结构 | Graph | 需要表示复杂的关系网络 | 有向图和无向图的基类，提供一些公共方法。 | 
|
| Directed Graph | 需要表示单向关系 | 一个网络状的兔子群，每只兔子最多可以有n条尾巴（单向链表）。 | 
|
|
| Undirected Graph | 需要表示双向关系 | 一个网络状的兔子群，每只兔子最多可以有n条尾巴（双向链表）。 | 
|
|
| 哈希结构 | HashMap | 需要快速的键值对查找 | 一种基于键的哈希值来存储数据的结构，允许以接近O(1)的时间复杂度进行插入、删除和查找操作。 | （图示暂缺） |
| 集合结构 | Multiset | 需要存储重复元素并快速统计元素出现次数 | 一种允许重复元素的集合，通常用于需要快速统计元素出现次数的场景。 | （图示暂缺） |
不同编程语言中的数据结构对应关系
| 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> | - | - |
内建的经典算法
| 算法 | 功能描述 | 迭代类型 |
|---|---|---|
| 二叉树深度优先搜索(DFS) | 以深度优先的方式遍历二叉树，从根节点开始，首先访问左子树，然后是右子树，使用递归。 | 递归 + 迭代 |
| 二叉树广度优先搜索(BFS) | 以广度优先的方式遍历二叉树，从根节点开始，逐层从左到右访问节点。 | 迭代 |
| 图的深度优先搜索 | 以深度优先的方式遍历图，从给定节点开始，尽可能深地沿一条路径探索，然后回溯以探索其他路径。用于寻找连通分量、路径等。 | 递归 + 迭代 |
| 二叉树Morris遍历 | Morris遍历是一种中序遍历二叉树的算法，空间复杂度为O(1)。它允许在没有额外栈或递归的情况下遍历树。 | 迭代 |
| 图的广度优先搜索 | 以广度优先的方式遍历图，从给定节点开始，首先访问与起始节点直接相连的节点，然后逐层扩展。用于寻找最短路径等。 | 递归 + 迭代 |
| 图的Tarjan算法 | 在图中找到强连通分量，通常使用深度优先搜索实现。 | 递归 |
| 图的Bellman-Ford算法 | 从单一源点找到最短路径，可以处理负权边 | 迭代 |
| 图的Dijkstra算法 | 从单一源点找到最短路径，不能处理负权边 | 迭代 |
| 图的Floyd-Warshall算法 | 找到所有节点对之间的最短路径 | 迭代 |
| 图的getCycles | 在图中找到所有循环或检测循环的存在。 | 递归 |
| 图的getCutVertices | 在图中找到切点，这些是移除后会增加图中连通分量数量的节点。 | 递归 |
| 图的getSCCs | 在图中找到强连通分量，这些是任意两个节点都可以相互到达的子图。 | 递归 |
| 图的getBridges | 在图中找到桥，这些是移除后会增加图中连通分量数量的边。 | 递归 |
| 图的拓扑排序 | 对有向无环图(DAG)进行拓扑排序，以找到节点的线性顺序，使得所有有向边都从较早的节点指向较晚的节点。 | 递归 |
软件工程标准
严格尊重计算机科学理论和软件开发规范，我们的LinkedList就是传统意义的LinkedList数据结构，而不是用Deque去代替以便标榜性能测试数据。当然我们也同时实现了基于动态数组的Deque。
| 原则 | 描述 |
|---|---|
| 实用性 | 遵循ES6和ESNext标准，提供统一且考虑周到的可选参数，简化方法名称。 |
| 可扩展性 | 遵循OOP（面向对象编程）原则，允许所有数据结构继承。 |
| 模块化 | 包括数据结构模块化和独立的NPM包。 |
| 效率 | 所有方法都提供时间和空间复杂度，可与原生JS性能相媲美。 |
| 可维护性 | 遵循开源社区开发标准，完整文档，持续集成，并遵循TDD（测试驱动开发）模式。 |
| 可测试性 | 自动化和定制单元测试、性能测试和集成测试。 |
| 可移植性 | 计划移植到Java、Python和C++，目前已完成80%。 |
| 可复用性 | 完全解耦，最小化副作用，遵循OOP。 |
| 安全性 | 精心设计的成员变量和方法的安全性。读写分离。数据结构软件不需要考虑其他安全方面。 |
| 可扩展性 | 数据结构软件不涉及负载问题。 |
基准测试
avl-tree
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 10,000 add randomly | 72.48 | 13.80 | 0.03 |
| 10,000 add & delete randomly | 144.14 | 6.94 | 0.03 |
| 10,000 addMany | 69.71 | 14.35 | 0.02 |
| 10,000 get | 54.21 | 18.45 | 0.01 |
binary-tree
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000 add randomly | 15.84 | 63.14 | 0.00 |
| 1,000 add & delete randomly | 24.62 | 40.62 | 0.00 |
| 1,000 addMany | 17.85 | 56.01 | 0.00 |
| 1,000 get | 20.83 | 48.00 | 0.00 |
| 1,000 has | 20.78 | 48.13 | 0.00 |
| 1,000 dfs | 186.06 | 5.37 | 0.02 |
| 1,000 bfs | 66.58 | 15.02 | 0.02 |
| 1,000 morris | 298.23 | 3.35 | 0.02 |
bst
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 10,000 add randomly | 55.04 | 18.17 | 0.01 |
| 10,000 add & delete randomly | 129.85 | 7.70 | 0.01 |
| 10,000 addMany | 50.40 | 19.84 | 0.01 |
| 10,000 get | 63.39 | 15.78 | 0.01 |
rb-tree
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add | 113.25 | 8.83 | 0.02 |
| 100,000 add & delete randomly | 305.28 | 3.28 | 0.03 |
| 100,000 getNode | 73.20 | 13.66 | 0.03 |
| 100,000 add & iterator | 159.80 | 6.26 | 0.06 |
comparison
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| SRC PQ 10,000 add | 0.17 | 5872.02 | 4.08e-5 |
| CJS PQ 10,000 add | 0.20 | 4961.22 | 1.14e-4 |
| MJS PQ 10,000 add | 0.74 | 1351.47 | 2.98e-4 |
| SRC PQ 10,000 add & pop | 4.62 | 216.49 | 0.00 |
| CJS PQ 10,000 add & pop | 4.36 | 229.40 | 0.00 |
| MJS PQ 10,000 add & pop | 3.92 | 255.23 | 0.00 |
directed-graph
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000 addVertex | 0.12 | 8557.70 | 2.46e-5 |
| 1,000 addEdge | 7.37 | 135.70 | 0.00 |
| 1,000 getVertex | 0.05 | 1.91e+4 | 1.12e-5 |
| 1,000 getEdge | 22.75 | 43.96 | 0.00 |
| tarjan | 196.98 | 5.08 | 0.01 |
| tarjan all | 217.25 | 4.60 | 0.03 |
| topologicalSort | 177.30 | 5.64 | 0.02 |
hash-map
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 set | 153.74 | 6.50 | 0.07 |
| 1,000,000 Map set | 330.02 | 3.03 | 0.16 |
| 1,000,000 Set add | 258.64 | 3.87 | 0.06 |
| 1,000,000 set & get | 138.80 | 7.20 | 0.06 |
| 1,000,000 Map set & get | 352.63 | 2.84 | 0.05 |
| 1,000,000 Set add & has | 217.97 | 4.59 | 0.02 |
| 1,000,000 ObjKey set & get | 414.87 | 2.41 | 0.06 |
| 1,000,000 Map ObjKey set & get | 389.17 | 2.57 | 0.07 |
| 1,000,000 Set ObjKey add & has | 352.67 | 2.84 | 0.03 |
heap
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add & pop | 90.67 | 11.03 | 0.02 |
| 100,000 add & dfs | 40.30 | 24.81 | 0.01 |
| 10,000 fib add & pop | 414.94 | 2.41 | 0.02 |
doubly-linked-list
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 290.62 | 3.44 | 0.10 |
| 1,000,000 unshift | 253.88 | 3.94 | 0.10 |
| 1,000,000 unshift & shift | 259.65 | 3.85 | 0.14 |
| 1,000,000 addBefore | 463.16 | 2.16 | 0.10 |
singly-linked-list
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push & shift | 250.27 | 4.00 | 0.08 |
| 10,000 push & pop | 261.13 | 3.83 | 0.03 |
| 10,000 addBefore | 282.46 | 3.54 | 0.02 |
max-priority-queue
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 10,000 refill & poll | 10.49 | 95.29 | 0.00 |
priority-queue
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 add & pop | 110.63 | 9.04 | 0.01 |
deque
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 15.89 | 62.92 | 0.00 |
| 1,000,000 push & pop | 26.45 | 37.81 | 0.01 |
| 1,000,000 push & shift | 27.52 | 36.34 | 0.00 |
| 1,000,000 unshift & shift | 28.82 | 34.70 | 0.01 |
queue
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 51.21 | 19.53 | 0.02 |
| 1,000,000 push & shift | 105.56 | 9.47 | 0.05 |
stack
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 1,000,000 push | 43.57 | 22.95 | 0.01 |
| 1,000,000 push & pop | 55.18 | 18.12 | 0.01 |
trie
| test name | time taken (ms) | executions per sec | sample deviation |
|---|---|---|---|
| 100,000 push | 54.08 | 18.49 | 0.01 |
| 100,000 getWords | 77.77 | 12.86 | 0.02 |