Js-collections-framework NPM

js-collections-framework

provides the basic javascript implementation of commonly used data structures.It includes following data structres

Demo

Get started

This library is been bulit to use on both server side (nodeJs) as well as on client (Html/JS).

install it using npm

    npm install js-collections-framework

or download the project and refer the JCF file present in the dist/ folder

    <script src="./dist/JCF.min.js"></script>

Stack

In computer science, a stack is an abstract data type that serves as a collection of elements, with two principal operations: push, which adds an element to the collection, and pop, which removes the most recently added element that was not yet removed. The order in which elements come off a stack gives rise to its alternative name, LIFO (for last in, first out). Additionally, a peek operation may give access to the top without modifying the stack.

How to use stack in JCF

In nodeJS

        var JCF = require('js-collections-framework');
        var stack = JCF.Stack;
        var myStack = new stack();

On Client Side(HTML/JS)

        //JCF is a global variable and will be available as soon as JCF lib is included
        var stack = JCF.Stack;
        var myStack = new stack();

Methods/Operations on stack

Method	Explanation	Example
.push(data)	used to push data on to stack	myStack.push(data);
.pop()	used to pop data from the stack	myStack.pop();
myStackindex	returns the data at the given index	myStack3
.length	retruns the length of the stack	myStack.length;

Complete Example

    <html>
    <head>
        <script src="https://rohithsathya.github.io/JCF/dist/JCF.min.js"></script>
        <script>
             var stack = JCF.Stack;
             var myStack = new stack();
             //push Data
             myStack.push("1");
             myStack.push("2");
             myStack.push("3");

             //print the stack data
             console.log("Printing Stack");
              for (var i = 0; i < myStack.length; i++) {
                console.log(myStack[i]);
            }

            //pop data
            myStack.pop();

             //print the stack data
             console.log("Printing Stack");
              for (var i = 0; i < myStack.length; i++) {
                console.log(myStack[i]);
            }

        </script>
    </head>
    <body>
        <h3>
            Look at the developer console for output
        </h3>
    </body>
</html>

Queue

Queue is an abstract data structure, somewhat similar to Stacks. Unlike stacks, a queue is open at both its ends. One end is always used to insert data (enqueue) and the other is used to remove data (dequeue). Queue follows First-In-First-Out methodology, i.e., the data item stored first will be accessed first.

How to use queue in JCF

In nodeJS

        var JCF = require('js-collections-framework');
        var queue = JCF.Queue;
        var myQueue = new queue();

On Client Side(HTML/JS)

        //JCF is a global variable and will be available as soon as JCF lib is included
        var queue = JCF.Queue;
        var myQueue = new queue();

Methods/Operations on stack

Method	Explanation	Example
.add(data)	used to push data on to queue	myQueue.add(data);
.remove()	used to remove an item from the queue	myQueue.remove();
.peek()	returns the next item from the queue	myQueue.peek();
myQueueindex	returns the data at the given index	myQueue3
.length	retruns the length of the queue	myQueue.length;

Complete Example

    <html>
    <head>
        <script src="https://rohithsathya.github.io/JCF/dist/JCF.min.js"></script>
        <script>
             var queue = JCF.Queue;
             var myQueue = new queue();
             //push Data
             myQueue.add("1");
             myQueue.add("2");
             myQueue.add("3");

             //print the stack data
             console.log("Printing Queue");
              for (var i = 0; i < myQueue.length; i++) {
                console.log(myQueue[i]);
            }

            //pop data
            myQueue.remove();

             //print the stack data
             console.log("Printing Queue");
              for (var i = 0; i < myQueue.length; i++) {
                console.log(myQueue[i]);
            }

            //peaking Queue
            console.log("Peaking Queue")
            console.log(myQueue.peek());

        </script>
    </head>
    <body>
        <h3>
            Look at the developer console for output
        </h3>
    </body>
</html>

Linked List

A linked list is a sequence of data structures, which are connected together via links. Linked List is a sequence of links which contains items. Each link contains a connection to another link. Linked list is the second most-used data structure after array.

How to use linkedlist in JCF

In nodeJS

        var JCF = require('js-collections-framework');
        var linkedList = JCF.LinkdeList;
        var myLinkedList = new linkedList();

On Client Side(HTML/JS)

        //JCF is a global variable and will be available as soon as JCF lib is included
        var queue = JCF.LinkdeList;
        var myLinkedList = new linkedList();

Methods/Operations on stack

Method	Explanation	Example
.addAtStart(data)	used to add data at the start of linked list	myLinkedList.addAtStart(data);
.addAtEnd(data)	used to add data at the end of linked list	myLinkedList.addAtEnd(data);
.addAt(data,pos)	used to add data at the given position of linked list	myLinkedList.addAtStart(data,pos);
.getHead()	used to add data at the Head/begining of linked list	myLinkedList.getHead();
.getTail()	used to add data at the Tail/end of linked list	myLinkedList.getTail(data,pos);
.itemAt(pos)	used to get data at the given position of linked list	myLinkedList.itemAt(pos);
.removeHead()	used to remove head from the linked list	myLinkedList.removeHead();
.removeTail()	used to remove tail from the linked list	myLinkedList.removeTail();
.removeAt(pos)	used to remove an item at a given position from the linked list	myLinkedList.removeAt(position);
.length	retruns the length of the linked list	myLinkedList.length;

Complete Example

   <html>
    <head>
        <script src="https://rohithsathya.github.io/JCF/dist/JCF.min.js"></script>
        <script>
             var linkedList = JCF.LinkedList;
             var myLinkedList = new linkedList();

        //add Data to LL
        console.log("Adding 1,2,3 to linked list");
        myLinkedList.addAtStart("1");
        myLinkedList.addAtStart("2");
        myLinkedList.addAtStart("3");
        console.log("prinitng...it should print 3,2,1");
        prinitLinkedList();
        myLinkedList.addAtEnd("4");
        console.log("prinitng...it should print 3,2,1,4");
        prinitLinkedList();
        myLinkedList.addAt("5", 2);
        console.log("prinitng...it should print 3,2,5,1,4");
        prinitLinkedList();

        console.log("Getting Head Node");
        console.log(myLinkedList.getHead());

        console.log("Getting Tail Node");
        console.log( myLinkedList.getTail());

        console.log("Getting Node At Position 2");
        console.log(myLinkedList.itemAt(2));
        

        console.log("Removing Node At Position 3");
        myLinkedList.removeAt(3);
        console.log("prinitng...it should print 3,2,5,4");
        prinitLinkedList();

        console.log("Removing Head Node");
        myLinkedList.removeHead();
        console.log("prinitng...it should print 2,5,4");
        prinitLinkedList();

        console.log("Removing Tail Node");
        myLinkedList.removeTail();
        console.log("prinitng...it should print 2,5");
        prinitLinkedList();

        function prinitLinkedList(){
            for (var i = 0; i < myLinkedList.length; i++) {
                console.log(myLinkedList.itemAt(i));
            }
        }
           

        </script>
    </head>
    <body>
        <h3>
            Look at the developer console for output
        </h3>
    </body>
</html>

Tree

In computer science, a tree is a widely used abstract data type (ADT)—or data structure implementing this ADT—that simulates a hierarchical tree structure, with a root value and subtrees of children with a parent node, represented as a set of linked nodes.

How to use tree in JCF

In nodeJS

        var JCF = require('js-collections-framework');
        var treeNode = JCF.Tree;
        var myRootNode = new treeNode("root");

On Client Side(HTML/JS)

        //JCF is a global variable and will be available as soon as JCF lib is included
        var treeNode = JCF.Tree;
        var myRootNode = new treeNode("root");

Methods/Operations on stack

Method	Explanation	Example
.addChild(node)	used to add a child node to a given node	myRootNode.addChild(node);
.getRoot()	used to get the root node of a given node	myChildNode.getRoot();
.getParent()	used to get the immediate parent of a given node	myChildNode.getParent();
.getChildren()	returns the list of all the imediate children of a given nodes	myRootNode.getChildren();
.getValue()	returns the value of a given node	myRootNode.getValue();
.delete()	deletes the given node from the tree	myRootNode.delete();
.toJson()	retruns the tree as json object	myRootNode.toJson();
.toString()	retruns the tree as string	myRootNode.toString();

Complete Example

  <html>
    <head>
        <script src="https://rohithsathya.github.io/JCF/dist/JCF.min.js"></script>
        <script>
             var treeNode = JCF.Tree;

        var rootNode = new treeNode("CEO");
        var engNode = new treeNode("ENG");
        var manNode = new treeNode("MAN");
        var opsNode = new treeNode("OPS");


        var emp1Node = new treeNode("emp1");
        var emp2Node = new treeNode("emp2");
        var emp3Node = new treeNode("emp3");
        var emp4Node = new treeNode("emp4");
        var emp5Node = new treeNode("emp5");
        var emp6Node = new treeNode("emp6");

        //now create a tree
        rootNode.addChild(engNode);
        rootNode.addChild(manNode);
        rootNode.addChild(opsNode);

        engNode.addChild(emp1Node);
        engNode.addChild(emp2Node);
        manNode.addChild(emp3Node);
        manNode.addChild(emp4Node);
        opsNode.addChild(emp5Node);
        opsNode.addChild(emp6Node);

        console.log("\n=====================TREE=====================\n");
        console.log("Printing Tree");
        console.log(rootNode.toJson());
        console.log("Printing root");
        console.log(emp1Node.getRoot());
        console.log("printing parent of emp3, it should be MAN");
        console.log(emp3Node.getParent());
        console.log("Prinitng children of ENG, should be emp1 and 2");
        console.log(engNode.getChildren());
        console.log("Prinitng the value of OPS dept, it should be OPS");
        console.log(opsNode.getValue());
        console.log("Deleting the OPS node");
        opsNode.delete();
        console.log(emp1Node.getRoot());
        </script>
    </head>
    <body>
        <h3>
            Look at the developer console for output
        </h3>
    </body>
</html>

Graph

A graph is a pictorial representation of a set of objects where some pairs of objects are connected by links. The interconnected objects are represented by points termed as vertices, and the links that connect the vertices are called edges. Formally, a graph is a pair of sets (V, E), where V is the set of vertices and E is the set of edges, connecting the pairs of vertices.

How to use graph in JCF

In nodeJS

        var JCF = require('js-collections-framework');
        var graphNode = JCF.GraphNode;
        var graph = JCF.Graph;

        var myGraph = new graph();
        var nodeA = new graphNode("A");

On Client Side(HTML/JS)

        //JCF is a global variable and will be available as soon as JCF lib is included
        var graphNode = JCF.GraphNode;
        var graph = JCF.Graph;

        var myGraph = new graph();
        var nodeA = new graphNode("A");

Methods/Operations on stack

Method	Explanation	Example
.addVertex(graphNode)	used to add a vertex into to a given graph	myGraph.addVertex(nodeA);
.addEdge(graphNodeSrc,graphNodeDest)	used to add an edge from src node to dest node	myGraph.addEdge(nodeA,nodeB);
.removeVertex(graphNode)	removes the given vertex from graph	myGraph.removeVertex(nodeA);
.removeEdge(graphNodeSrc,graphNodeDest)	removes an edge b/w src node and dest node	myGraph.removeEdge(nodeA,nodeB);
.getAllVertices()	returns the list of all the vertices in the graph	myGraph.getAllVertices();
.getAdjacentVertices(graphNode)	returns the list of adjacent vertices of a given vertex	myGraph.getAdjacentVertices(nodeA);
.getOutdegree(graphNode)	retruns the out degree of a given vertex	myGraph.getOutdegree(nodeA);
.getIndegree(graphNode)	retruns the in degree of a given vertex	myGraph.getIndegree(nodeA);
.toJson()	retruns the graph as json object for persistence	myGraph.toJson();
.toString()	retruns the graph as string for persistence	myGraph.toString();
.loadFromJson(jsonObj)	used to load the graph from json persisted previously	myGraph.loadFromJson(graphJson);
.dfs(startingNode)	retruns DFS path for a given starting node	myGraph.dfs(nodeA);
.bfs(startingNode)	retruns BFS path for a given starting node	myGraph.bfs(nodeA);

Complete Example

  <html>

<head>
    <script src="https://rohithsathya.github.io/JCF/dist/JCF.min.js"></script>
    <script>
        var graphNode = JCF.GraphNode;
        var graph = JCF.Graph;

        var myGraph = new graph();
        var nodeA = new graphNode("A");
        var nodeB = new graphNode("B");
        var nodeC = new graphNode("C");
        var nodeD = new graphNode("D");


        myGraph.addVertex(nodeA);
        myGraph.addVertex(nodeB);
        myGraph.addVertex(nodeC);
        myGraph.addVertex(nodeD);

        myGraph.addEdge(nodeA, nodeB);
        myGraph.addEdge(nodeA, nodeC);
        myGraph.addEdge(nodeA, nodeD);
        myGraph.addEdge(nodeB, nodeD);

        console.log("\n============GRAPH===================\n");
        console.log("Prinitng all vertices");
        console.log(myGraph.getAllVertices())
        console.log("Prinitng Neigbhours of nodeA, this should be B,C,D");
        console.log(myGraph.getAdjacentVertices(nodeA));
        console.log("Prinitng outdegree of A, it should be 3");
        console.log(myGraph.getOutdegree(nodeA));
        console.log("Prinitng indegree of B, it should be 1");
        console.log(myGraph.getIndegree(nodeB));
        console.log("Prinitng the graph in JSON");
        console.log(myGraph.toJson());
        console.log("DFS startting with nodeB");
        console.log(myGraph.dfs(nodeB));
        console.log("BFS startting with nodeA");
        console.log(myGraph.dfs(nodeA));
        console.log("remove Edge between a and b");
        myGraph.removeEdge(nodeA, nodeB);
        console.log("Prinitng outdegree of A, it should be 2");
        console.log(myGraph.getAdjacentVertices(nodeA));
        console.log("Removing vertex nodeB");
        myGraph.removeVertex(nodeB);
        console.log("Prinitng the graph in JSON");
        console.log(myGraph.toJson());
    </script>
</head>

<body>
    <h3>
        Look at the developer console for output
    </h3>
</body>

</html>

collections javascript stack queue graph linkedlist list linked tree

@everything-registry/sub-chunk-1974 @zalastax/nolb-js-c

0.0.3

7 years ago

0.0.2

7 years ago

0.0.1

7 years ago