stack and depth first search

Author: chen0040

README.md

@@ -1,4 +1,27 @@
 # js-graph-algorithms
 Package provides javascript implementation of algorithms for graph processing
 
-[![Build Status](https://travis-ci.org/chen0040/js-graph-algorithms.svg?branch=master)](https://travis-ci.org/chen0040/js-graph-algorithms) [![Coverage Status](https://coveralls.io/repos/github/chen0040/js-graph-algorithms/badge.svg?branch=master)](https://coveralls.io/github/chen0040/js-graph-algorithms?branch=master) 
+[![Build Status](https://travis-ci.org/chen0040/js-graph-algorithms.svg?branch=master)](https://travis-ci.org/chen0040/js-graph-algorithms) [![Coverage Status](https://coveralls.io/repos/github/chen0040/js-graph-algorithms/badge.svg?branch=master)](https://coveralls.io/github/chen0040/js-graph-algorithms?branch=master) 
+
+# Usage
+
+### Create an undirected unweighted graph
+
+The sample code below shows how to create a undirected and unweighted graph:
+
+```javascript
+jsgraphs = require('js-graph-algorithms');
+
+var g = new jsgraphs.Graph(6);
+g.addEdge(0, 5); // add undirected edge connecting vertex 0 to vertex 5
+g.addEdge(2, 4);
+g.addEdge(2, 3);
+g.addEdge(1, 2);
+g.addEdge(0, 1);
+g.addEdge(3, 4);
+g.addEdge(3, 5);
+g.addEdge(0, 2);
+
+console.log(g.V); // display 6, which is the number of vertices in g
+console.log(g.adj(0)); // display [5, 1, 2], which is the adjacent list to vertex 0
+```

src/jsgraphs.js

@@ -1,6 +1,75 @@
 var jsgraphs = jsgraphs || {};
 
 (function(jss){
+    var StackNode = function (value) {
+        this.value = value;
+        this.next = null;
+    };
+    
+    jss.StackNode = StackNode;
+    
+    var Stack = function() {
+        this.N = 0;
+        this.first = null;
+    };
+    
+    Stack.prototype.push = function (a) {
+        this.first = this._push(this.first, a);  
+    };
+    
+    Stack.prototype._push = function(x, a) {
+        if(x == null) {
+            this.N++;
+            return new jss.StackNode(a);
+        }  
+        var oldX = x;
+        this.N++;
+        x = new jss.StackNode(a);
+        x.next = oldX;
+        return x;
+    };
+    
+    Stack.prototype.pop = function () {
+        if (this.first == null) {
+            return undefined;
+        }  
+        
+        var oldFirst = this.first;
+        var item = oldFirst.value;
+        this.first = oldFirst.next;
+        this.N--;
+        
+        return item;
+    };
+    
+    Stack.prototype.size = function() {
+        return this.N;  
+    };
+    
+    Stack.prototype.isEmpty = function() {
+        return this.N == 0;  
+    };
+    
+    Stack.prototype.peep = function() {
+        if (this.first == null) {
+            return undefined;
+        }  
+        
+        return this.first.value;
+    };
+    
+    Stack.prototype.toArray = function() {
+        var result = [];
+        x = this.first;
+        while (x != null) {
+            result.push(x.value);
+            x = x.next;
+        }
+        return result;
+    };
+    
+    jss.Stack = Stack;
+    
 	var Graph = function (V) {
         this.V = V;
         this.adjList = [];
@@ -19,6 +88,48 @@ var jsgraphs = jsgraphs || {};
     };
 
     jss.Graph = Graph;
+    
+    var DepthFirstSearch = function(G, s) {
+        this.s = s;
+        var V = G.V;
+        this.marked = [];
+        this.edgeTo = [];
+        for (var v = 0; v < V; ++v) {
+            this.marked.push(false);
+            this.edgeTo.push(-1);
+        }
+        
+        this.dfs(G, s);
+    };
+    
+    DepthFirstSearch.prototype.dfs = function (G, v) {
+        this.marked[v] = true;
+        var adj_v = G.adj(v);
+        for (var i = 0; i < adj_v.length; ++i){
+            var w = adj_v[i];
+            if (!this.marked[w]){
+                this.edgeTo[w] = v;
+                this.dfs(G, w);
+            }
+        }
+    };
+    
+    DepthFirstSearch.prototype.hasPathTo = function(v) {
+        return this.marked[v];
+    };
+    
+    DepthFirstSearch.prototype.pathTo = function(v) {
+        var path = new jss.Stack();
+        if(v == this.s) return [v];
+        
+        for(var x = v; x != this.s; x = this.edgeTo[x]) {
+            path.push(x);
+        }
+        path.push(this.s);
+        return path.toArray();
+    };
+    
+    jss.DepthFirstSearch = DepthFirstSearch;
 
 })(jsgraphs);
 

test/depth-first-search-spec.js

@@ -0,0 +1,28 @@
+var expect = require('chai').expect;
+var jsgraphs = require('../src/jsgraphs');
+
+describe('Depth first search', function(){
+   it('should traverse correctly', function(){
+        var g = new jsgraphs.Graph(6);
+        g.addEdge(0, 5);
+        g.addEdge(2, 4);
+        g.addEdge(2, 3);
+        g.addEdge(1, 2);
+        g.addEdge(0, 1);
+        g.addEdge(3, 4);
+        g.addEdge(3, 5);
+        g.addEdge(0, 2);
+        var s = 0;
+        var dfs = new jsgraphs.DepthFirstSearch(g, s);
+        
+
+        for(var v=0; v < g.V; ++v) {
+         if(dfs.hasPathTo(v)) {
+            console.log(s + " is connected to " + v);
+            console.log("path: " + dfs.pathTo(v));
+         } else {
+             console.log('No path from ' + s + ' to ' + v);
+         }
+        } 
+   });
+});

test/stack-spec.js

@@ -0,0 +1,32 @@
+var expect = require('chai').expect;
+var jsgraphs = require('../src/jsgraphs');
+
+describe('Stack operations', function(){
+   describe('Stack push and pop', function(){
+        
+       
+        it('should be able to push, peep and pop', function(){
+            var stack = new jsgraphs.Stack();
+            stack.push(10);
+            expect(stack.size()).to.equal(1);
+            expect(stack.peep()).to.equal(10);
+            expect(stack.pop()).to.equal(10);
+            expect(stack.size()).to.equal(0);
+            expect(stack.isEmpty()).to.equal(true);
+            for(var i = 0; i < 100; ++i) {
+                stack.push(i);
+                expect(stack.size()).to.equal(i+1);
+            }
+            var a = stack.toArray();
+            for(var i = 0; i < 100; ++i) {
+                expect(a[i]).to.equal(100 - i - 1);  
+            }
+            
+            for(var i = 0; i < 100; ++i) {
+                expect(stack.pop()).to.equal(100 - i - 1);
+                expect(stack.size()).to.equal(100 -i - 1);
+            }
+            
+        });
+   });
+});