myCompFn(arg1, arg2)

//Create and AVLTree (extends a BinarySearchTree)
var AVLTree = require("dsjslib").AVLTree
var avl=new AVLTree([compareFn]) //optional compare fn to sort the keys

//Insert a key value. It also re-balances the tree
avl.put(key,value)

//Get a value for key
avl.get(key)


//Remove key vallue, also rebalances the tree
avl.delete(key)

//Predecessor and Successor
avl.predecessor(key)  avl.successor(key) 


//Inorder traversal of the tree. callbackfn called for every node visited
avl.traverse([node],callbackfn)

//Min and Max - if start node not given, starts at root
avl.min([startAtNode]) avl.max([startAtNode])

// Validates the tree starting at given node (root otherwise). 
// Validates BST as well as AVL proeprties
avl.checkInvariants([startAtNode])
                                     

//Print the tree starting at root (requires util module from Node.js)
console.log(avl.root)

//Create a Skip List
//Optional compare function to order the keys. If not provided, a natural ordering is
//assumed.

var SkipList = require("dsjslib").SkipList
var skl=new SkipList(compareFn)

//Add a key value
skl.put(k,v)

//Search for a key
skl.get(k)

//delete a key and its associated value
skl.delete(k)

//Get all entries(sorted). They are returned as key value pair objects
skl.entrySet()

Creates a BTree of degree K .
Any node in the Tree can have a maximum of 2*K-1 keys  and a minimum of K-1 keys.

var BTree = require("dsjslib").BTree

var btree=new BTree(K) 

//Inserts a key and splits nodes as required
btree.put(key,value)

//Search by key
btree.get(key)

//Deletes a key and re-joins nodes and/or reduces the height of tree as required
btree.delete(key)

//Check various BTree invariants -- For sanity testing
1. Except root all nodes have degree -1 <keys<2*degree-1
2. Child keys are less than corresponding parent key 
   (and greater than predecessor parent key)

btree.checkInvariants()

// Creates a RWayTrie of alphabet size R .
//For example if you know that the keys are made of ASCII chars only, R=128. 
//Each node in this trie will have an array of size R. 

var RWayTrie = require("dsjslib").RWayTrie
var rTrie=new RWayTrie(R) 

// Inserts a key and set its value as val
rTrie.put(key,val) 

//Search for a key and return associated value or null
rTrie.get(key) 

//Deletes a key 
rTrie.delete(key) 

//Return a list of all key, value pairs in sorted order (of keys)
rTrie.entrySet() 

//Return a list of all key, value pairs where
//keys start with given prefix_chars
rTrie.keysWithPrefix(prefix_chars) 

//Creates a TernarySearchTrie
var TernarySearchTrie = require("dsjslib").TernarySearchTrie
var tst=new TernarySearchTrie() 

//Insert a key value pair into the Trie
tst.put(key,val) 

//Search for key and return associated value or null
tst.get(key) 

//Deletes a key and associated value
tst.delete(key) 

//Return a list of all key, value pairs where
//keys start with given prefix_chars
tst.keysWithPrefix(prefix_chars)                                      

//Creates a MultiMap
var MultiMap = require("dsjslib").MultiMap
var mm=new MultiMap() 

//Insert a key value pair into the Map.
//If the key is already present, the value will be added to the existing list,
//otherwise, an array is created and the value is added to the array

mm.put(key,val) 

//Search for key and return associated value array or empty array
//This method never returns null even if the key is not present
//Any changes made to the returned array modify the underlying array in the MultiMap as well

mm.get(key) 

//Test if a key is present in Map or not. This doesn't modify the Map to create empty array if
//the key was not present.
mm.hasKey(key)

//If a value is provided, only that value is removed from the list
//If value is not provided, key and all values are deleted from the MultiMap

mm.delete(key, [value]) 

//Return a list of all key, value pairs.
//The key value pairs are returned as objects {'key':<K>,'value':<V>}
//Note that for keys associated with multiple values there is one object per value returned in the entry
//for example for key1->val1,val2,val3 , the entries will be
//[{'key':key1,'value':val1},{'key':key1,'value':val2},{'key':key1,'value':val3}]

mm.entries()

//Creates a TreeMultiMap
var TreeMultiMap = require("dsjslib").TreeMultiMap
var mm=new TreeMultiMap([compareFn]) 

//@see MultiMap
mm.put(key,val) 

//@see MultiMap
mm.get(key) 

//@see MultiMap
mm.hasKey(key)

//@see MultiMap
mm.remove(key, [value]) 

//Return a list of all key, value pairs. In addition, the returned list is sorted on keys
//The key value pairs are returned as objects {'key':<K>,'value':<V>}
//Note that for keys associated with multiple values there is one object per value returned in the entry
//for example for key1->val1,val2,val3 , the entries will be
//[{'key':key1,'value':val1},{'key':key1,'value':val2},{'key':key1,'value':val3}]
mm.entries()

 myCompFn(arg1, arg2)

//Creates a PriorityQueue
var PriorityQueue = require("dsjslib").PriorityQueue
var pq=new PriorityQueue([compareFn]) 


//Insert the object in queue. Re-heapifies the queue.
pq.offer(obj) 

//Returns and removes the element at the head of the queue . Re-heapifies the queue..
//The head of this queue is the maximum element 
//with respect to the specified ordering. If multiple elements 
//are tied for max value, the head is one of those elements -- ties are broken arbitrarily.
pq.poll() 

//Get the head of the queue without removing it from the queue
pq.peek() 

//Returns array of elements in the queue. Ordering of those elements in undefined
pq.entries()

//Cleanup and remove all elements from the queue
pq.clear()

//Returns the number of elements in the queue
pq.size()

//Creates a LinkedDeque
var LinkedDeque = require("dsjslib").LinkedDeque
var ldq=new LinkedDeque([capacity]) 


//Add obj to the head of the Deque. Equivalen to ldq.unshift(obj)
//Returns true if obj was successfully added, false if it failed (for example, if the Deque is at 
//full capacity)
ldq.offerFirst(obj)

//Add obj to the head of the Deque.
ldq.unshift(obj)

//Add obj to the tail of the Deque. Equivalen to ldq.push(obj)
//Returns true if obj was successfully added, false if it failed (for example, if the Deque is at 
//full capacity)
ldq.offerLast(obj)

//Add obj to the end of the Deque.
ldq.push(obj)


//Returns and removes the element at the head of the Deque.
//Returns null if there is no such element
//Equivalent to ldq.shift()
ldq.pollFirst() 

//Returns and removes the element at the head of the Deque
ldq.shift()

//Returns and removes the element at the tail of the Deque
//Returns null if there is no such element
//Equivalent to ldq.pop()
ldq.pollLast()

//Returns and removes the element at the tail of the Deque
ldq.pop()

//Returns an array containing all of the elements in this Deque, 
//in proper sequence (from first to last element).
//The returned array has no links/pointers to the Deque. 
//No items are removed from the Deque
ldq.toArray() 

//Get the size of the Deque
ldq.size()

//Remove all items from the Deque
ldq.clear()