Merge branch 'gh-pages' of https://github.com/parkjs814/AlgorithmVisualizer into gh-pages

64json · 64json · commit 306f229ee73d · 2016-05-24T02:50:17.000-05:00
diff --git a/algorithm/category.json b/algorithm/category.json
@@ -6,7 +6,14 @@
       "bfs": "BFS",
       "dijkstra": "Dijkstra",
       "bellman_ford": "Bellman-Ford",
-      "floyd_warshall": "Floyd-Warshall"
+      "floyd_warshall": "Floyd-Warshall",
+      "topological_sort": "Topological-Sort"
+    }
+  },
+  "mst": {
+    "name": "Minimum Spanning Tree",
+    "list": {
+      "prim": "Prim's Algorithm"
     }
   },
   "search": {
@@ -26,6 +33,12 @@
       "heap" : "Heap Sort"
     }
   },
+  "string": {
+   		"name": "String",
+   		"list": {
+   			"edit_distance": "Edit Distance"
+   		}
+   },
   "etc": {
     "name": "Uncategorized",
     "list": {
diff --git a/algorithm/etc/dp/desc.json b/algorithm/etc/dp/desc.json
@@ -10,6 +10,7 @@
   "files": {
     "fibonacci": "Fibonacci Sequence",
     "sliding_window": "Finding the largest sum of three contiguous number",
-    "max_sum_path": "Finding the maximum sum in a path from (0, 0) to (N-1, M-1) when can only move to right or down"
+    "max_sum_path": "Finding the maximum sum in a path from (0, 0) to (N-1, M-1) when can only move to right or down",
+    "longest_increasing_subsequence": "Find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order"
   }
 }
diff --git a/algorithm/etc/dp/longest_increasing_subsequence/code.js b/algorithm/etc/dp/longest_increasing_subsequence/code.js
@@ -0,0 +1,31 @@
+tracer._pace(500);
+
+// Initialize LIS values for all indexes 
+for( var i = 0; i < 20; i++) {
+	LIS[i] = 1;
+}
+
+tracer._print( 'Calculating Longest Increasing Subsequence values in bottom up manner ');
+// Compute optimized LIS values in bottom up manner
+for( var i = 1; i < 10; i++) {
+	tracer._select(i) ;
+	tracer._print( ' LIS['+i+'] = ' + LIS[i]);
+	for( var j =0; j < i; j++) {
+		tracer._notify(j);
+		if( A[i] > A[j] && LIS[i] < LIS[j] + 1) {
+			LIS[i] = LIS[j] + 1;
+			tracer._print( ' LIS['+i+'] = ' + LIS[i]);
+		}
+	}
+	tracer._deselect(i);
+}
+
+// Pick maximum of all LIS values
+tracer._print( 'Now calculate maximum of all LIS values ');
+var max = LIS[0];
+for( var i = 1; i < 10; i++) {
+	if(max < LIS[i]) {
+		max = LIS[i];
+	}
+}
+tracer._print('Longest Increasing Subsequence = max of all LIS = ' + max);
diff --git a/algorithm/etc/dp/longest_increasing_subsequence/data.js b/algorithm/etc/dp/longest_increasing_subsequence/data.js
@@ -0,0 +1,4 @@
+var tracer = new Array1DTracer();
+var A = Array1D.random(10, 0, 10);
+var LIS = new Array(10);
+tracer._setData(A);
diff --git a/algorithm/graph_search/topological_sort/desc.json b/algorithm/graph_search/topological_sort/desc.json
@@ -0,0 +1,21 @@
+{
+  "Topological-Sort": "Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge uv, vertex u comes before v in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG. NOTE: when the graph is represented as an Adjacency Matrix, the Calculation of in-degree Array becomes O(|V|<sup>2</sup>)",
+  "Applications": [
+    "Job Scheduling",
+    "Instruction Scheduling",
+    "Logic Synthesis",
+    "Determining the order of compilation tasks to perform in makefiles",
+    "Data serialization"
+  ],
+  "Complexity": {
+    "time": "worst O(|V|+|E|)",
+    "space": "worst O(|V|)"
+  },
+  "References": [
+    "<a href='http://www.geeksforgeeks.org/topological-sorting-indegree-based-solution/'>GeeksForGeeks</a>",
+    "<a href='http://www.geeksforgeeks.org/topological-sorting/'>GeeksForGeeks</a>"
+  ],
+  "files": {
+    "kahn_algorithm": "Performing Topological Sort using Queue Data Structure & an array of In-degrees"
+  }
+}
diff --git a/algorithm/graph_search/topological_sort/kahn_algorithm/code.js b/algorithm/graph_search/topological_sort/kahn_algorithm/code.js
@@ -0,0 +1,59 @@
+tracer._pace(100);
+tracer._sleep(1000);
+
+(function topologicalSort () {
+	var inDegrees = Array.apply (null, Array (G.length)).map (Number.prototype.valueOf, 0);		//create an Array of G.length number of 0s
+	var Q = [], iter = 0, i;
+
+	tracer._print ('Calculating in-degrees for each Node...');
+	for (var currNode = 0; currNode < G.length; currNode++) {
+		for (var currNodeNeighbor = 0; currNodeNeighbor < G.length; currNodeNeighbor++) {
+			if (G [currNode] [currNodeNeighbor]) {
+				tracer._print (currNodeNeighbor + ' has an incoming edge from ' + currNode);
+				tracer._visit (currNodeNeighbor, currNode);
+				inDegrees [currNodeNeighbor]++;
+				tracer._leave (currNodeNeighbor, currNode);
+			}
+		}
+	}
+	tracer._print ('Done. In-Degrees are: [ ' + String (inDegrees) + ' ]');
+	tracer._print ('');
+
+	tracer._print ('Initializing queue with all the sources (nodes with no incoming edges)');
+	inDegrees.map (function (indegrees, node) {
+		tracer._visit (node);
+		if (!indegrees) {
+			tracer._print (node + ' is a source');
+			Q.push (node);
+		}
+		tracer._leave (node);
+	});
+	tracer._print ('Done. Initial State of Queue: [ ' + String (Q) + ' ]');
+	tracer._print ('');
+
+	//begin topological sort (kahn)
+	while (Q.length > 0) {
+		tracer._print ('Iteration #' + iter + '. Queue state: [ ' + String (Q) + ' ]');
+		currNode = Q.shift (1);
+		tracer._visit (currNode);
+
+		for (i = 0; i < G.length; i++) {
+			if (G [currNode] [i]) {
+				tracer._print (i + ' has an incoming edge from ' + currNode + '. Decrementing ' + i + '\'s in-degree by 1.');
+				tracer._visit (i, currNode);
+				inDegrees [i]--;
+				tracer._leave (i, currNode);
+
+				if (!inDegrees [i]) {
+					tracer._print (i + '\'s in-degree is now 0. Enqueuing ' + i);
+					Q.push (i);
+				}
+			}
+		}
+		tracer._leave (currNode);
+		tracer._print ('In-degrees are: [' + String (inDegrees) + ' ]');
+		tracer._print ('-------------------------------------------------------------------');
+
+		iter++;
+	}
+}) ();
diff --git a/algorithm/graph_search/topological_sort/kahn_algorithm/data.js b/algorithm/graph_search/topological_sort/kahn_algorithm/data.js
@@ -0,0 +1,12 @@
+var tracer = new DirectedGraphTracer ();
+// G[i][j] indicates whether the path from the i-th node to the j-th node exists or not. NOTE: The graph must be Directed-Acyclic
+var G = [
+	[0, 0, 0, 0, 0, 0],
+	[0, 0, 1, 0, 0, 0],
+	[0, 0, 0, 1, 0, 0],
+	[0, 0, 0, 0, 0, 0],
+	[1, 0, 0, 1, 0, 0],
+	[1, 1, 0, 0, 0, 0]
+];
+
+tracer._setData (G);
diff --git a/algorithm/mst/prim/desc.json b/algorithm/mst/prim/desc.json
@@ -0,0 +1,14 @@
+{
+  "Prim's Algorithm": "Greedy algorithm that finds a minimum spanning tree for a weighted undirected graph.",
+  "Applications": [
+  ],
+  "Complexity": {
+    "time": "worst O(|V|<sup>2</sup>)"
+  },
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Prim%27s_algorithm'>Wikipedia</a>"
+  ],
+  "files": {
+    "normal": "Finds minimum spanning tree of a given graph."
+  }
+}
diff --git a/algorithm/mst/prim/normal/code.js b/algorithm/mst/prim/normal/code.js
@@ -0,0 +1,32 @@
+function prim(){
+  // Finds a tree so that there exists a path between
+  // every two nodes while keeping the cost minimal
+  var minD, minI, minJ, sum=0, D=[];
+  for(var i = 0; i < G.length; i++) D.push(0);
+  D[0] = 1; // First node is visited
+  for(var k = 0; k < G.length-1; k++){ // Searching for k edges
+    minD = Infinity;
+    for(i = 0; i< G.length; i++)
+      if(D[i]) // First node in an edge must be visited
+        for(var j = 0; j < G.length; j++)
+          if(!D[j] && G[i][j]){
+            tracer._visit(i, j);
+            // Second node must not be visited and must be connected to first node
+            if(G[i][j] < minD){
+              // Searching for cheapest edge which satisfies requirements
+              minD = G[i][j];
+              minI = i;
+              minJ = j;
+            }
+            tracer._leave(i, j);
+          }
+    tracer._visit(minI, minJ);
+    D[minJ] = 1; // Visit second node and insert it into or tree
+    sum += G[minI][minJ];
+  }
+  tracer._print("The sum of all edges is: " + sum);
+}
+
+tracer._pace(500);
+tracer._print("nodes that belong to minimum spanning tree are: ");
+prim();
diff --git a/algorithm/mst/prim/normal/data.js b/algorithm/mst/prim/normal/data.js
@@ -0,0 +1,10 @@
+var tracer = new WeightedUndirectedGraphTracer();
+/*var G = [ // G[i][j] indicates the weight of the path from the i-th node to the j-th node
+ [0, 3, 0, 1, 0],
+ [5, 0, 1, 2, 4],
+ [1, 0, 0, 2, 0],
+ [0, 2, 0, 0, 1],
+ [0, 1, 3, 0, 0]
+ ];*/
+var G = WeightedUndirectedGraph.random(10, .4, 1, 9);
+tracer._setData(G);
diff --git a/algorithm/string/edit_distance/desc.json b/algorithm/string/edit_distance/desc.json
@@ -0,0 +1,18 @@
+{
+  "Edit-Distance": "Given two strings str1 (length M) and str2 (length N) and below operations that can performed on str1. Find minimum number of edits (operations) required to convert str1 into str2.<br />Insert<br />Remove<br />Replace<br />All of the above operations are of equal cost",
+  "Applications": [
+    "Displaing Near-Proximity Words",
+    "Information Retrieval (eg- Lucene API)",
+    "Natural Language Processing"
+  ],
+  "Complexity": {
+    "time": "worst O(|M|.|N|)",
+    "space": "worst O(|M|.|N|)"
+  },
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Edit_distance'>Wikipedia</a>"
+  ],
+  "files": {
+    "dynamic_programming": "Distance from str1 to str2 using Dynamic Programming (2D Array method)"
+  }
+}
diff --git a/algorithm/string/edit_distance/dynamic_programming/code.js b/algorithm/string/edit_distance/dynamic_programming/code.js
@@ -0,0 +1,40 @@
+tracer._pace (200);
+tracer._print ('Initialized DP Table');
+tracer._print ('Y-Axis (Top to Bottom): ' + str1);
+tracer._print ('X-Axis (Left to Right): ' + str2);
+
+var dist = (function editDistance (str1, str2, table) {
+	//display grid with words
+	tracer._print ('*** ' + str2.split ('').join (' '));
+	table.forEach (function (item, index) {
+		var character = (index === 0) ? '*' : str1 [index-1];
+		tracer._print (character + '\t' + item);
+	});
+
+	//begin ED execution
+	for (var i = 1; i < str1.length+1; i++) {
+		for (var j = 1; j < str2.length+1; j++) {
+			if (str1 [i-1] === str2 [j-1]) {
+				tracer._select (i-1, j-1);
+				table [i] [j] = table [i-1] [j-1];
+				tracer._notify (i, j);
+				tracer._deselect (i-1, j-1);
+			}
+			else {
+				tracer._select (i-1, j);
+				tracer._select (i, j-1);
+				tracer._select (i-1, j-1);
+				table [i] [j] = Math.min (table [i-1] [j], table [i] [j-1], table [i-1] [j-1]) + 1;
+				tracer._notify (i, j);
+				tracer._deselect (i-1, j);
+				tracer._deselect (i, j-1);
+				tracer._deselect (i-1, j-1);
+			}
+		}
+	}
+
+	tracer._select (str1.length, str2.length);
+	return table [str1.length] [str2.length];
+}) (str1, str2, table);
+
+tracer._print ('Minimum Edit Distance: ' + dist);
diff --git a/algorithm/string/edit_distance/dynamic_programming/data.js b/algorithm/string/edit_distance/dynamic_programming/data.js
@@ -0,0 +1,10 @@
+var tracer = new Array2DTracer ();
+var str1 = 'stack', str2 = 'racket', table = new Array (str1.length + 1);
+
+table [0] = Array.apply (null, {length: str2.length + 1}).map (Number.call, Number);
+for (var i = 1; i < str1.length+1; i++) {
+	table [i] = Array.apply (null, Array (str2.length+1)).map (Number.prototype.valueOf, -1);
+	table [i] [0] = i
+}
+
+tracer._setData (table);
diff --git a/css/stylesheet.css b/css/stylesheet.css
@@ -10,6 +10,23 @@ body {
     color: rgb(187, 187, 187);
 }
 
+*::-webkit-scrollbar {
+      width: 15px;
+} 
+*::-webkit-scrollbar-track {
+      background-color: #3C3F41;
+} 
+ 
+*::-webkit-scrollbar-thumb {
+      background-color: rgba(0, 0, 0, 0.2); 
+} 
+*::-webkit-scrollbar-button {
+      background-color: #7c2929;
+} 
+*::-webkit-scrollbar-corner {
+      background-color: #3C3F41;
+}
+
 a {
     text-decoration: none;
 }
@@ -214,6 +231,7 @@ section {
     padding: 0 8px;
     line-height: 30px;
     font-size: 12px;
+    overflow-y: auto;
 }
 
 .data_container {
@@ -304,4 +322,4 @@ pre {
 
 .mtbl-cell.notifying {
     background: #f00;
-}
+}
diff --git a/img/favicon.ico b/img/favicon.ico
diff --git a/img/image.png b/img/image.png
diff --git a/index.html b/index.html
@@ -2,6 +2,11 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
+    <meta name="description" content="Tool for visualizing algorithms." />
+    <meta property="og:title" content="Algorithm Visualizer" />
+    <meta property="og:description" content="Tool for visualizing algorithms." />
+    <meta property="og:image" content="img/image.png" />
+    <link rel="shortcut icon" href="img/favicon.ico" type="image/x-icon" />
     <title>Algorithm Visualizer</title>
     <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto">
     <link rel="stylesheet" href="css/font-awesome.min.css">

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`"files": {`
`11`	`11`	`"fibonacci": "Fibonacci Sequence",`
`12`	`12`	`"sliding_window": "Finding the largest sum of three contiguous number",`
`13`		`- "max_sum_path": "Finding the maximum sum in a path from (0, 0) to (N-1, M-1) when can only move to right or down"`
	`13`	`+ "max_sum_path": "Finding the maximum sum in a path from (0, 0) to (N-1, M-1) when can only move to right or down",`
	`14`	`+ "longest_increasing_subsequence": "Find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order"`
`14`	`15`	`}`
`15`	`16`	`}`