Socket
Socket
Sign inDemoInstall

@diotoborg/ratione-similique

Package Overview
Dependencies
29
Maintainers
0
Versions
52
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@diotoborg/ratione-similique


Version published
Maintainers
0
Created

Readme

Source

data-structure-typed

npm GitHub contributors npm package minimized gzipped size (select exports) GitHub top language GITHUB Star eslint NPM npm

Installation and Usage

npm

npm i data-structure-typed --save

yarn

yarn add data-structure-typed
import {
  Heap, Graph, Queue, Deque, PriorityQueue, BST, Trie, DoublyLinkedList,
  AVLTree, SinglyLinkedList, DirectedGraph, RedBlackTree, TreeMultiMap,
  DirectedVertex, Stack, AVLTreeNode
} from 'data-structure-typed';

If you only want to use a specific data structure independently, you can install it separately, for example, by running

npm i heap-typed --save

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

Performance

Performance surpasses that of native JS/TS

MethodTime TakenData ScaleBelongs Tobig O
Queue.push & shift5.83 ms100KOursO(1)
Array.push & shift2829.59 ms100KNative JSO(n)
Deque.unshift & shift2.44 ms100KOursO(1)
Array.unshift & shift4750.37 ms100KNative JSO(n)
HashMap.set122.51 ms1MOursO(1)
Map.set223.80 ms1MNative JSO(1)
Set.add185.06 ms1MNative JSO(1)

Conciseness and uniformity

In java.utils, you need to memorize a table for all sequential data structures(Queue, Deque, LinkedList),

Java ArrayListJava QueueJava ArrayDequeJava LinkedList
addofferpushpush
removepollremoveLastremoveLast
removepollremoveFirstremoveFirst
add(0, element)offerFirstunshiftunshift

whereas in our data-structure-typed, you only need to remember four methods: push, pop, shift, and unshift for all sequential data structures(Queue, Deque, DoublyLinkedList, SinglyLinkedList and Array).

Data structures available

We provide data structures that are not available in JS/TS

Data StructureUnit TestPerf TestAPI DocNPMDownloads
Binary TreeDocsNPMNPM Downloads
Binary Search Tree (BST)DocsNPMNPM Downloads
AVL TreeDocsNPMNPM Downloads
Red Black TreeDocsNPMNPM Downloads
Tree MultimapDocsNPMNPM Downloads
HeapDocsNPMNPM Downloads
Priority QueueDocsNPMNPM Downloads
Max Priority QueueDocsNPMNPM Downloads
Min Priority QueueDocsNPMNPM Downloads
TrieDocsNPMNPM Downloads
GraphDocsNPMNPM Downloads
Directed GraphDocsNPMNPM Downloads
Undirected GraphDocsNPMNPM Downloads
QueueDocsNPMNPM Downloads
DequeDocsNPMNPM Downloads
Hash MapDocs
Linked ListDocsNPMNPM Downloads
Singly Linked ListDocsNPMNPM Downloads
Doubly Linked ListDocsNPMNPM Downloads
StackDocsNPMNPM Downloads
Segment TreeDocs
Binary Indexed TreeDocs

Vivid Examples

AVL Tree

Try it out, or you can run your own code using our visual tool

Tree Multi Map

Try it out

Directed Graph

Try it out

Map Graph

Try it out

Code Snippets

Red Black Tree snippet

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

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

Binary Search Tree (BST) snippet

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);

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

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']


API docs & Examples

API Docs

Live Examples

Examples Repository

Benchmark

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

heap
test nametime taken (ms)executions per secsample deviation
100,000 add6.09164.121.35e-4
100,000 add & poll34.5528.946.43e-4
rb-tree
test nametime taken (ms)executions per secsample deviation
100,000 add76.7313.030.00
100,000 add randomly80.6712.400.00
100,000 get110.869.020.00
100,000 iterator24.9940.020.00
100,000 add & delete orderly152.666.550.00
100,000 add & delete randomly230.754.330.00
queue
test nametime taken (ms)executions per secsample deviation
1,000,000 push39.2725.460.01
100,000 push & shift4.53220.814.84e-4
Native JS Array 100,000 push & shift1948.050.510.02
deque
test nametime taken (ms)executions per secsample deviation
1,000,000 push23.2243.060.00
1,000,000 push & pop29.6833.690.00
1,000,000 push & shift29.3334.090.00
100,000 push & shift3.10323.012.47e-4
Native JS Array 100,000 push & shift1942.120.510.02
100,000 unshift & shift2.77360.502.43e-4
Native JS Array 100,000 unshift & shift3835.210.260.03
hash-map
test nametime taken (ms)executions per secsample deviation
1,000,000 set112.388.900.02
Native JS Map 1,000,000 set199.975.000.01
Native JS Set 1,000,000 add163.346.120.01
1,000,000 set & get109.869.100.02
Native JS Map 1,000,000 set & get255.333.920.00
Native JS Set 1,000,000 add & has163.916.100.00
1,000,000 ObjKey set & get317.893.150.04
Native JS Map 1,000,000 ObjKey set & get282.993.530.03
Native JS Set 1,000,000 ObjKey add & has253.933.940.03
trie
test nametime taken (ms)executions per secsample deviation
100,000 push43.7122.887.33e-4
100,000 getWords83.6311.960.00
avl-tree
test nametime taken (ms)executions per secsample deviation
100,000 add271.933.680.01
100,000 add randomly318.273.140.00
100,000 get128.857.760.00
100,000 iterator29.0934.380.00
100,000 add & delete orderly435.482.307.44e-4
100,000 add & delete randomly578.701.730.00
binary-tree-overall
test nametime taken (ms)executions per secsample deviation
10,000 RBTree add randomly6.69149.541.06e-4
10,000 RBTree get randomly9.19108.821.43e-4
10,000 RBTree add & delete randomly18.5453.941.73e-4
10,000 AVLTree add randomly23.7042.201.88e-4
10,000 AVLTree get randomly9.89101.110.00
10,000 AVLTree add & delete randomly44.4422.504.30e-4
directed-graph
test nametime taken (ms)executions per secsample deviation
1,000 addVertex0.109766.659.83e-7
1,000 addEdge6.15162.577.99e-4
1,000 getVertex0.052.18e+44.52e-7
1,000 getEdge22.7044.060.00
tarjan203.004.930.01
topologicalSort176.405.670.00
doubly-linked-list
test nametime taken (ms)executions per secsample deviation
1,000,000 push222.024.500.07
1,000,000 unshift220.414.540.05
1,000,000 unshift & shift185.315.400.01
1,000,000 addBefore317.203.150.07
singly-linked-list
test nametime taken (ms)executions per secsample deviation
1,000,000 push & shift204.824.880.09
10,000 push & pop221.884.510.03
10,000 addBefore247.284.040.01
priority-queue
test nametime taken (ms)executions per secsample deviation
100,000 add26.9737.087.97e-4
100,000 add & poll74.5513.415.19e-4
stack
test nametime taken (ms)executions per secsample deviation
1,000,000 push35.5428.140.00
1,000,000 push & pop44.8922.270.01

The corresponding relationships between data structures in different language standard libraries.

Data Structure TypedC++ STLjava.utilPython 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>--

Built-in classic algorithms

AlgorithmFunction DescriptionIteration Type
Binary Tree DFSTraverse 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 BFSTraverse a binary tree in a breadth-first manner, starting from the root node, visiting nodes level by level from left to right. Iteration
Graph DFSTraverse 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 MorrisMorris 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 BFSTraverse 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 AlgorithmFind strongly connected components in a graph, typically implemented using depth-first search.Recursion
Graph Bellman-Ford AlgorithmFinding the shortest paths from a single source, can handle negative weight edgesIteration
Graph Dijkstra's AlgorithmFinding the shortest paths from a single source, cannot handle negative weight edgesIteration
Graph Floyd-Warshall AlgorithmFinding the shortest paths between all pairs of nodesIteration
Graph getCyclesFind all cycles in a graph or detect the presence of cycles.Recursion
Graph getCutVerticesFind cut vertices in a graph, which are nodes that, when removed, increase the number of connected components in the graph. Recursion
Graph getSCCsFind strongly connected components in a graph, which are subgraphs where any two nodes can reach each other. Recursion
Graph getBridgesFind bridges in a graph, which are edges that, when removed, increase the number of connected components in the graph. Recursion
Graph topologicalSortPerform 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

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.

PrincipleDescription
PracticalityFollows ES6 and ESNext standards, offering unified and considerate optional parameters, and simplifies method names.
ExtensibilityAdheres to OOP (Object-Oriented Programming) principles, allowing inheritance for all data structures.
ModularizationIncludes data structure modularization and independent NPM packages.
EfficiencyAll methods provide time and space complexity, comparable to native JS performance.
MaintainabilityFollows open-source community development standards, complete documentation, continuous integration, and adheres to TDD (Test-Driven Development) patterns.
TestabilityAutomated and customized unit testing, performance testing, and integration testing.
PortabilityPlans for porting to Java, Python, and C++, currently achieved to 80%.
ReusabilityFully decoupled, minimized side effects, and adheres to OOP.
SecurityCarefully designed security for member variables and methods. Read-write separation. Data structure software does not need to consider other security aspects.
ScalabilityData structure software does not involve load issues.

supported module system

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

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;

Keywords

FAQs

Last updated on 14 Jul 2024

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc