Needle

<img src="https://travis-ci.org/nickzuber/needle.svg?branch=master" /> <img src="https://img.shields.io/badge/license-mit-blue.svg?style=flat" /> <img src="https://badge.fury.io/js/node-needle.svg" /> <br /> <img src="https://david-dm.org/nickzuber/Needle/dev-status.svg" /> <img src="https://david-dm.org/nickzuber/Needle.svg" />

Needle is a standalone extensive data structure library in JavaScript.

Install as an npm package or download the minified file of the latest version.

Installation

You can install Needle as a node package with npm, and it's as easy as:

$ npm install --save node-needle

If you prefer to use Needle on the client side, just download the minified file of the latest version and include it in your webpage:

<!-- The complete Needle library -->
<script src="path/to/needle.min.js"></script>

Usage

When you have Needle installed, you can use it on the server in Node like so:

const Needle = require('node-needle');

// Example: Create a new instance of a hashmap
var map = Needle.Hashmap();

or you can just use it on the client side like so:

// Needle gets pushed onto the global scope under the alias "Needle"
var bst = new Needle.BinarySearchTree();

API Reference

Needle has a variety of different data structures at its disposal. Here is a reference to all of the currently available data structures that Needle supports. Some data structures have not been added yet and they will appear unavailable.

If you feel that there should be additional data structures added to this library, send me a message and let me know what you had in mind.

Note: In the API, * refers to any type. This is commonly used when specifying the type of data; since all types of data are supported when inserting custom data into a data structure.

---

Arrays

• Bit Array
• Bitmap
• Hashed Array Tree
• Sorted Array

Lists

• Doubly Linked List
• Singly Linked List
• Queue
• Stack

Heaps

• Binary Heap
• Binomial Heap
• Soft Heap

General Trees

• Trie
• Radix Tree
• B Trie

Binary Trees

• Binary Search Tree
• AVL Tree
• B Tree
• B+ Tree
• Red-Black Tree

Multiway Trees

• Ternary Tree
• K-ary Tree
• And-Or Tree

Metric Trees

• VP Tree
• BK Tree
• M Tree
• Cover Tree

Hashes

• Hashmap
• Concurrent Hash Trie
• Rolling Hash

Graphs

• Adjacency Matrix
• Directed Graph
• Multigraph

---

<a href="#bst" name="bst">Needle.BinarySearchTree()</a>

root - Node - The root node of the binary tree.<br /> compare - function - Compares two elements to each other to determine the ordering of the heap.<br />

Note: The default compare function is defined as

function defaultCompare(a, b){
  return (a < b);
}

• (constructor)([< function >compare]) - object - Creates a Binary Search Tree and if a function is passed in, it overrides the default compare function with the function defined by compare.
• hasRight(< Node >node) - boolean - Returns true if the given Node has a right component.
• hasLeft(< Node >node) - boolean - Returns true if the given Node has a left component.
• isLeaf(< Node >node) - boolean - Returns true if the given Node is a leaf.
• emptySubtree(< Node >node) - void - Empties the subtree of the given Node.
• emptyTree() - void - Empties the entire tree.
• heightSubtree(< Node >node) - number - Returns the height of the subtree derived from Node.
• numNodesSubtree(< Node >node) - number - Returns the number of nodes of the subtree derived from Node.
• numLeavesSubtree(< Node >node) - number - Returns the number of leaves of the subtree derived from Node.
• insert(< * >data [, < Node >node]) - void - Inserts a node into the binary search tree given by data. The Node argument will determine which subtree to attempt to insert the node at. Inserting at the root subtree is selected by default if this parameter is left blank (recommended).
• search(< * >data [, < Node >node]) - Node || false - Searched for the node given by data in the binary search tree. The Node argument will determine which subtree to attempt to search for the node. Searching at the root subtree is selected by default if this parameter is left blank (recommended).

<a href="#binaryheap" name="binaryheap">Needle.BinaryHeap()</a>

heap - Array - The array based heap acting as a binary heap.<br /> compare - function - Compares two elements to each other to determine the ordering of the heap.<br />

Note: The default compare function is defined as

function defaultCompare(a, b){
  return (a < b);
}

• (constructor)([< function >compare]) - object - Creates a Binary Heap and if a function is passed in, it overrides the default compare function with the function defined by compare.
• peek() - element - Returns the root or top element of the heap.
• size() - number - Returns the amount of elements stored in the heap.
• insert(< * >data) - void - Inserts the element given by data into the heap and adjusts the heap accordingly.
• delete() - void - Removes the root or top element from the heap and adjusts the heap accordingly.
• heapify(< array >arr) - void - Converts the input array into a legal binary heap.

<a href="#bitarray" name="bitarray">Needle.BitArray()</a>

data - Array - The array of bit sequences.<br />

• (constructor)([< number >size = 0]) - object - Creates a Bit Array and allocates memory for the size if argument is given.
• get(< number >index) - number - Returns the bit in the BitArray at location index.
• set(< number >index, < boolean >value) - void -
• size(< number >size) - void -
• resize() - void - Adjusts the BitArray size to the given argument size.
• complement() - BitArray - Resolves the complement of the calling BitArray.
• union(< BitArray >bitarray) - BitArray - Resolves the union between the calling BitArray and the argument bitarray.
• intersection(< BitArray >bitarray) - BitArray - Resolves the intersection between the calling BitArray and the argument bitarray.
• difference(< BitArray >bitarray) - BitArray - Resolves the difference between the calling BitArray and the argument bitarray.

<a href="#doublylinkedlist" name="doublylinkedlist">Needle.DoublyLinkedList()</a>

head - Node - The first node in the linked list.<br /> tail - Node - The last node in the linked list.<br /> size - number - The number of nodes in the linked list.<br />

• (constructor)([< * >data]) - object - Creates a Doubly Linked List and inserts a node at the head of the newly created list if data is given.
• insertFront(< * >data) - void - Create a node from data and inserts at the front of the list.
• insertNth(< number >index, < * >data) - boolean - Create a node from data and insert in the location of the linked list specified by index.
• insertAfter(< * >targetData, < * >data) - boolean - Create a node from data and insert after the node which has the data specified by targetData and returns true if the element was successfully added to the linked list.
• insertBack(< * >data) - void - Create a node from data and inserts at the back of the list.
• remove(< * >data) - boolean - Removes the element specified by data and returns true if the element was successfully found and removed from the linked list.
• removeNth(< number >index) - void - Removes the element in the location of the linked list specified by index.
• find(< * >data) - Node || false - Finds the element specified by data and returns that Node if the element was successfully found but returns false if the node was not found.
• findNth(< number >index) - Node - Finds the element in the location of the linked list specified by index and returns that Node.

<a href="#hashmap" name="hashmap">Needle.Hashmap()</a>

state - number - Holds the current hash of the internal window.<br />

• (constructor)() - object - Creates and instatiates a Hashmap object.
• put(< * >key, < * >value) - void - Inserts an entry into the hashmap, which maps the given key to its respective value.
• get(< * >key) - value - Returns the value that is paired with the given key.
• delete(< * >key) - boolean - Deletes the entry that is associated with the given key, returns true if deletion was successful and false if the entry was not found.
• iterator() - key - Resets the internal iterator Node to the first entry and returns the unhashed key.
• next() - key - Iterates to the next Node and returns an the unhashed key.
• size() - number - Returns the amount of unique entries within the hashmap.

<a href="#rollinghash" name="rollinghash">Needle.RollingHash()</a>

state - number - The internal hash value of the current window.<br />

• (constructor)(< number >base) - object - Creates and instatiates a rolling hash object and an argument is passed in which assigns the base of the rolling hash.
• set(< string || Array >arg) - void - Sets the internal window of the rolling hash given arg in the relative base.
• slide(< string || number >old, < *string