abstract-data

#Basic abstract data types for JavaScript Built by Audun Bjornerud Mo. @audun, audun.io

npm install abstract-data var abs = require('abstract-data'); or clone the repo and put abstract.js with your project and import with: <script src="abstract.js"></script>

Current types:

• Stacks
• Linked Lists

Planned types:

• Binary trees
• Queues
• Dequeues
• Heaps

##Stacks

Stacks have five attributes: .length, .push(), .pop(), .pushAll(), .popAll(), and are instantiated as empty by:

Client-side

var abs = new AbstractJS();
    myStack = new abs.Stack();

Node

var abs = require('abstract-data');
    myStack = news abs.Stack();

###Basics

• Stack.push(item) pushes item onto the stack.
• Stack.pop() retrieves the last item to pushed, and removes it from the the stack.
• Stack.length holds the length of the stack as a number

###Advanced

####Stack.pushAll(Object || Array input, string modifier, bool reverse) Stack.pushAll() takes a parameter input that is either an array or a generic JS-object, and an optionalmodifier given as a string. modifier changes the manner in which input is pushed onto the stack, if input is an object. It is entirely optional.

#####Arrays The default behavior for Stack.pushAll(array) is to push from left to right, that is array[0] to array[array.length - 1]. However, if the last parameter is true, then this order is turned around. Example:

var abs = new AbstractJS(),
    myStack = new abs.Stack(),
    myArray = [1,2, 'three', function(){return '4'}];

myStack.pushAll(myArray);
//results in a stack with order: 1,2, 'three', function(){return '4'}

myStack.popAll() //Empties the stack

myStack.pushAll(myArray, '', true)
//results in a stack with order: function(){return '4'}, 'three', 1,2

######Objects The default behavior for Stack.pushAll(object) is to push key-value pairs of the form {key : value}. The modifier can here be used to only record keys, or only record values Example:

var abs = new AbstractJS();
    myStack = new abs.Stack(),
    myObj = {
    key_one : val_one,
    key_two : vale_two,
    key_three : val_three
    };

myStack.pushAll(myObj);
//results in a stack like: {key_one : value_one}, {key_two : value_two}, {key_three : value_three}

myStack.popAll(); //Empties the stack

myStack.pushAll(myObj, 'keys');
//results in a stack like: key_one, key_two, key_three

myStack.popAll();

myStack.pushall(myObj, 'values');
//results in a stack like: value_one, value_two, value_three

####Stack.popAll(callback(popped)) Stack.popAll() takes an optional callback. This callback is given the popped item as a parameter. The callback executes, and then repeats with the next object on the stack until the stack is empty. If no callback is specified, the stack will be emptied.

For example:

var abs = new AbstractJS();
    executionStack = new abs.Stack(),
    numbersToDouble = [1,2,3,4,5,6],
    results = [];

executionStack.pushAll(numbersToDouble);
executionStack.popAll(function(popped){
    results.append(popped * 2);
});

##Linked Lists Linked lists consist of a set of nodes, each of which containing a reference to the next node in the sequence. Instantiating an empty Linked List is done by: ``` var abs = new AbstractJS(), LL = new abs.LinkedList(); ``` ####LLNodes LLNodes are the constituent parts of a Linked List. They are instantiated, always with a 'value' and 'next' property (undefined if this is the last node), like this: ``` var abs = new AbstractJS(), LLNodeTwo = new abs.LLNode('this is my value', undefined), LLNodeOne = new abs.LLNode('this is the first value', LLNodeTwo); ```

LLNodes can be added to a linked list manually by LinkedList.addNode(LLNode) but there are also two other ways of adding LLNodes:

######LinkedList.addAllNodes(startingNode) This starts at the given node, then recursively adds startingNode.next, continuing until it hits a node where node.next is undefined

######LinkedList.makeFromArray(array) This loops over the given array, adding the elements as it goes. The elements do not have to be LLNodes. Suppose array[i] is not undefined. If array[i+1] is also not undefined, an LLNode is created with myLLNode.value = array[i] and myLLNode.next = array[i+1], otherwise myLLNode.next = undefined and the loop stops. This LLNode is then added to the Linked List.

Properties:

• LinkedList.length is a number, containing the length of the Linked List.

Built-in methods

• LinkedList.iterateOver(callback(node)) iterates over all the nodes in the list, and executes a callback on them