breadth first search

Author: chen0040

README.md

@@ -3,6 +3,14 @@ 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) 
 
+# Features
+
+* Depth First Search
+* Breadth First Search
+* Minimum Spanning Tree (Kruskal, Prim Lazy, Prim Eager)
+* Shortest Paths (Dijkstra, Bellman-Ford, Topological Sort on DAG)
+* MaxFlow-MinCut (Ford-Fulkerson)
+
 # Usage
 
 ### Create an undirected unweighted graph
@@ -24,4 +32,34 @@ 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
+```
+
+### Depth First Search
+
+The sample code below show how to perform depth first search of an undirected graph
+
+```javascript
+jsgraphs = require('js-graph-algorithms');
+
+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);
+ }
+} 
 ```

src/jsgraphs.js

@@ -70,6 +70,69 @@ var jsgraphs = jsgraphs || {};
 
     jss.Stack = Stack;
 
+    var QueueNode = function(a) {
+        this.value = a;  
+        this.next = null;
+    };
+    
+    jss.QueueNode = QueueNode;
+    
+    var Queue = function() {
+        this.first = null;
+        this.last = null;
+        this.N = 0;
+    };
+    
+    Queue.prototype.enqueue = function(item) {
+        var oldLast = this.last;
+        this.last = new jss.QueueNode(item);
+        if(oldLast != null){
+            oldLast.next = this.last;
+        }
+        if (this.first == null) {
+            this.first = this.last;
+        }
+        this.N++;
+    };
+    
+    Queue.prototype.dequeue = function() {
+        if(this.first == null) {
+            return undefined;
+        }  
+        
+        var oldFirst = this.first;
+        var item = oldFirst.value;
+        this.first = oldFirst.next;
+        
+        if(this.first == null) {
+            this.last = null;
+        }
+        
+        this.N--;
+        
+        return item;
+    };
+    
+    Queue.prototype.size = function() {
+        return this.N;  
+    };
+    
+    Queue.prototype.isEmpty = function() {
+        return this.N == 0;
+    };
+    
+    Queue.prototype.toArray = function() {
+        var result = [];
+        var x = this.first;
+        while (x != null) {
+            result.push(x.value);
+            x = x.next;
+        }
+        return result;
+    };
+    
+    jss.Queue = Queue;
+    
 	var Graph = function (V) {
         this.V = V;
         this.adjList = [];
@@ -130,6 +193,51 @@ var jsgraphs = jsgraphs || {};
     };
 
     jss.DepthFirstSearch = DepthFirstSearch;
+    
+    var BreadthFirstSearch = function(G, s) {
+        var V = G.V;
+        this.s = s;
+        
+        var queue = new jss.Queue();
+        queue.enqueue(s);
+        this.marked = [];
+        this.edgeTo = [];
+        
+        for(var v = 0; v < V; ++v) {
+            this.marked.push(false);
+            this.edgeTo.push(-1);
+        }
+        
+        while (!queue.isEmpty()) {
+            var v = queue.dequeue();
+            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;
+                    queue.enqueue(w);
+                }
+            }
+        }
+    };
+    
+    BreadthFirstSearch.prototype.hasPathTo = function(v) {
+        return this.marked[v];
+    };
+    
+    BreadthFirstSearch.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.BreadthFirstSearch = BreadthFirstSearch;
 
 })(jsgraphs);
 

test/breadth-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 bfs = new jsgraphs.BreadthFirstSearch(g, s);
+        
+
+        for(var v=0; v < g.V; ++v) {
+         if(bfs.hasPathTo(v)) {
+            console.log(s + " is connected to " + v);
+            console.log("path: " + bfs.pathTo(v));
+         } else {
+             console.log('No path from ' + s + ' to ' + v);
+         }
+        } 
+   });
+});

test/queue-spec.js

@@ -0,0 +1,22 @@
+var expect = require('chai').expect;
+var jsgraphs = require('../src/jsgraphs');
+
+describe('Queue operations', function() {
+    it('should enqueue and dequeue correctly', function() {
+        var queue = new jsgraphs.Queue();  
+        queue.enqueue(10);
+        queue.enqueue(20);
+        queue.enqueue(30);
+        var a = queue.toArray();
+        expect(a.length).to.equal(3);
+        for(var i=0; i < a.length; ++i) {
+            expect(a[i]).to.equal((i+1) * 10);
+        }
+        expect(queue.size()).to.equal(3);
+        expect(queue.isEmpty()).to.equal(false);
+        expect(queue.dequeue()).to.equal(10);
+        expect(queue.dequeue()).to.equal(20);
+        expect(queue.dequeue()).to.equal(30);
+        expect(queue.isEmpty()).to.equal(true);
+    });
+});