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

64json · 64json · commit 909b5fb10e38 · 2016-05-26T13:38:22.000-05:00
diff --git a/algorithm/category.json b/algorithm/category.json
@@ -30,33 +30,36 @@
       "insertion": "Insertion Sort",
       "selection": "Selection Sort",
       "bubble": "Bubble Sort",
-      "quick": "Quicksort",
       "merge": "Merge Sort",
-      "heap" : "Heapsort",
       "radix": "Radix Sort",
+      "quick": "Quicksort",
+      "heap" : "Heapsort",
       "shell": "Shellsort"
     }
   },
   "string": {
    		"name": "String",
    		"list": {
-   			"edit_distance": "Edit Distance"
+   			"edit_distance": "Edit Distance",
+   			"knuth_morris_pratt": "KMP Substring Search"
    		}
    },
    "dp": {
     "name": "Dynamic Programming",
     "list": {
-      "fibonacci": "Fibonacci sequence",
-      "knapsack_problem": "Knapsack problem",
-      "longest_increasing_subsequence": "Longest increasing subsequence",
-      "max_subarray": "Maximum subarray",
-      "max_sum_path": "Maximum sum path",
-      "sliding_window": "Sliding window"
+      "fibonacci": "Fibonacci Sequence",
+      "knapsack_problem": "Knapsack Sroblem",
+      "longest_increasing_subsequence": "Longest Increasing Subsequence",
+      "max_subarray": "Maximum Subarray",
+      "max_sum_path": "Maximum Sum Path",
+      "sliding_window": "Sliding Window",
+      "integer_partition": "Integer Partition"
     }
    },
   "etc": {
     "name": "Uncategorized",
     "list": {
+       "flood_fill": "Flood Fill"
     }
   }
 }
diff --git a/algorithm/dp/integer_partition/basic/code.js b/algorithm/dp/integer_partition/basic/code.js
@@ -0,0 +1,32 @@
+function partition(A, n, p){
+  if (n === 0) tracer.logTracer._print('[' + A.join(', ') + ']');
+  else {
+    var end = n;
+    if (p !== 0 && A[p-1] < n) end = A[p-1];
+    for (var i = end; i > 0; i--){
+        A[p] = i;
+        partition(A, n-i, p+1);
+    }
+  }
+}
+
+function integerPartition(n){
+  //Calculate number of partitions for all numbers from 1 to n
+  for (var i = 2; i <= n; i++){
+    // We are allowed to use numbers from 2 to i
+    for (var j = 1; j <= i; j++){
+      // Number of partitions without j number + number of partitions with max j
+      tracer._select(i, j)._wait();
+      D[i][j] = D[i][j-1] + D[i-j][Math.max(j, i-j)];
+      tracer._notify(i, j, D[i][j])._wait();
+      tracer._denotify(i, j);
+      tracer._deselect(i, j);
+    }
+  }
+  return D[n][n];
+}
+
+tracer.logTracer._print('Partitioning: ' + integer);
+partition(A, integer, 0);
+var part = integerPartition(integer);
+tracer.logTracer._print(part);
diff --git a/algorithm/dp/integer_partition/basic/data.js b/algorithm/dp/integer_partition/basic/data.js
@@ -0,0 +1,10 @@
+var tracer = new Array2DTracer().attach(new LogTracer());
+var integer = Math.floor(Math.random() * 10) + 5;
+var D = [], A = [];
+for (var i = 0; i <= integer; i++){
+  D.push([]);
+  D[0][i] = 1;
+  D[i][1] = 1;
+  for (var j = 0; j <= integer; j++) D[i][j]=0;
+}
+tracer._setData(D);
diff --git a/algorithm/dp/integer_partition/desc.json b/algorithm/dp/integer_partition/desc.json
@@ -0,0 +1,13 @@
+{
+  "Integer Partition": "In number theory and combinatorics, a partition of a positive integer n, also called an integer partition, is a way of writing n as a sum of positive integers.",
+  "Complexity": {
+    "time": "O(n(log n))",
+    "space": "O(n<sup>2</sup>)"
+  },
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Partition_(number_theory)'>Wikipedia</a>"
+  ],
+  "files": {
+    "basic": "Integer partition"
+  }
+}
diff --git a/algorithm/dp/knapsack_problem/desc.json b/algorithm/dp/knapsack_problem/desc.json
@@ -1,7 +1,7 @@
 {
   "Knapsack Problem": "Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible.",
   "Complexity": {
-    "time": "O(n<sup>2</sup>",
+    "time": "O(n<sup>2</sup>)",
     "space": "O(n<sup>2</sup>)"
   },
   "References": [
diff --git a/algorithm/etc/flood_fill/desc.json b/algorithm/etc/flood_fill/desc.json
@@ -0,0 +1,9 @@
+{
+  "Flood Fill": "Flood fill, also called seed fill, is an algorithm that determines the area connected to a given node in a multi-dimensional array",
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Flood_fill'>Wikipedia</a>"
+  ],
+  "files": {
+    "flood_fill": ""
+  }
+}
diff --git a/algorithm/etc/flood_fill/flood_fill/code.js b/algorithm/etc/flood_fill/flood_fill/code.js
@@ -0,0 +1,20 @@
+function FloodFill(i, j, oldColor, newColor) {
+
+    if (i < 0 || i >= G.length || j < 0 || j >= G[i].length) return;
+    if (G[i][j] != oldColor) return;
+
+    // set the color of node to newColor
+    G[i][j] = newColor;
+
+    tracer._select(i, j)._wait();
+    tracer._notify(i, j, G[i][j])._wait();
+
+    // next step four-way
+    FloodFill(i + 1, j, oldColor, newColor);
+    FloodFill(i - 1, j, oldColor, newColor);
+    FloodFill(i, j + 1, oldColor, newColor);
+    FloodFill(i, j - 1, oldColor, newColor);
+}
+
+FloodFill(4, 4, '-', 'a');
+
diff --git a/algorithm/etc/flood_fill/flood_fill/data.js b/algorithm/etc/flood_fill/flood_fill/data.js
@@ -0,0 +1,13 @@
+var tracer = new Array2DTracer ();
+var G = [
+    ['#', '#', '#', '#', '#', '#', '#', '#', '#'],
+    ['#', '-', '-', '-', '#', '-', '-', '-', '#'],
+    ['#', '-', '-', '-', '#', '-', '-', '-', '#'],
+    ['#', '-', '-', '#', '-', '-', '-', '-', '#'],
+    ['#', '#', '#', '-', '-', '-', '#', '#', '#'],
+    ['#', '-', '-', '-', '-', '#', '-', '-', '#'],
+    ['#', '-', '-', '-', '#', '-', '-', '-', '#'],
+    ['#', '-', '-', '-', '#', '-', '-', '-', '#'],
+    ['#', '#', '#', '#', '#', '#', '#', '#', '#']
+];
+tracer._setData(G);
diff --git a/algorithm/graph_search/bridges/desc.json b/algorithm/graph_search/bridges/desc.json
@@ -1,7 +1,7 @@
 {
-  "Bridges": "An edge in an undirected connected graph is a bridge iff removing it disconnects the graph. A naive solution to finding bridges in a graph is to:<br />1.Delete an edge E<br />2.Perform DFS Exploration to check is Graph is connected<br />3.Restore Edge E. E is a bridge only if DFS explore determines that the graph is disconnected without E",
+  "Bridges": "An edge in an undirected connected graph is a bridge iff removing it disconnects the graph. A naive solution to finding bridges in a graph is to:<br />1.Delete an edge E<br />2.Perform DFS Exploration to check if the Graph is still connected<br />3.Restore Edge E. E is a bridge only if DFS exploration determines that the graph is disconnected without E",
   "Applications": [
-    "Find vulnerabilities in Graphs and Electrical Circuits"
+    "Finding vulnerabilities in Graphs and Electrical Circuits"
   ],
   "Complexity": {
     "time": "worst O(|E|.(|V|+|E|))",
diff --git a/algorithm/string/knuth_morris_pratt/desc.json b/algorithm/string/knuth_morris_pratt/desc.json
@@ -0,0 +1,16 @@
+{
+  "Knuth-Morris-Pratt": "searches for occurrences of a substring W with length K within a main string S with Length N by employing the observation that when a mismatch occurs, the word itself embodies sufficient information to determine where the next match could begin, thus bypassing re-examination of previously matched characters",
+  "Applications": [
+    "Substring Search"
+  ],
+  "Complexity": {
+    "time": "worst O(|N|+|K|)",
+    "space": "worst O(|K|)"
+  },
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm'>Wikipedia</a>"
+  ],
+  "files": {
+    "substring_search": "Efficiently find is A is a substring of B (and A's position(s))"
+  }
+}
diff --git a/algorithm/string/knuth_morris_pratt/substring_search/code.js b/algorithm/string/knuth_morris_pratt/substring_search/code.js
@@ -0,0 +1,108 @@
+//Fix JS Negative number modulo Bug
+Number.prototype.mod = function (n) {
+    return ((this%n)+n)%n;
+};
+
+function tracker (substring) {
+	var i = 1, j = 0;
+
+	logger._print ('Initializing i to 1, j to 0.');
+	substrTracer._select (j);
+	while (i < track.length) {
+		substrTracer._select (i)._wait ();
+
+		while ( (substring [i] !== substring [j]) && (j > 0) ) {
+			logger._print ('j = ' + track [j-1]);
+			trackTracer._select (j-1)._wait ();
+			trackTracer._deselect (j-1)._wait ();
+
+			substrTracer._deselect (j);
+			j = track [j-1];
+			logger._print ('j = ' + j);
+			substrTracer._select (j);
+		}
+
+		if (substring [i] === substring [j]) {
+			substrTracer._deselect (j);
+			track [i] = ++j;
+			trackTracer._notify (i, track [i])._wait ();
+			trackTracer._denotify (i)._wait ();
+			logger._print ('substring [ ' + i + ' ] (' + substring [i] + ') equals substring [ ' + j + ' ] (' + substring [j] + '), track [ ' + i + ' ] updated to: ' + track [i]);
+
+			logger._print ('j = ' + j);
+			substrTracer._select (j);
+		}
+		else {
+			track [i] = 0;
+			logger._print ('substring [ ' + i + ' ] (' + substring [i] + ') is not equal to substring [ ' + j + ' ] (' + substring [j] + '), setting track [' + i + '] to 0');
+			trackTracer._select (i)._wait ();
+			trackTracer._deselect (i)._wait ();
+		}
+
+		substrTracer._deselect (i)._wait ();
+		i++;
+		logger._print ('i = ' + i);
+	}
+
+	return track;
+}
+
+function kmp (string, substr) {
+	var positions = [], j = 0, startPos;
+
+	logger._print ('Constructing Tracker for substring <b>' + substr + '</b>');
+	track = tracker (substr);
+	logger._print ('Tracker for substring constructed: [ ' + String (track) + ' ]');
+	logger._print ('--------------------------------------------------------------------------');
+	logger._print ('Running KMP...');
+
+	logger._print ('Initializing i = 0, j = 0');
+	for (var i = 0; i < string.length; i++) {
+		logger._print ('comparing string [' + i + '] (' + string [i] + ') and substring [' + j + '] (' + substr [j] + ')...');
+		stringTracer._select (i)._wait ();
+		stringTracer._select (j)._wait ();
+
+		if (string [i] === substr [j]) {
+			logger._print ('they\'re equal!');
+
+			if (j === substr.length-1) {
+				logger._print ('j (' + j + ') equals length of substring - 1 (' + substr.length + '-1), we\'ve found a new match in the string!');
+				startPos = i - substr.length + 1;
+				positions.push (startPos);
+
+				logger._print ('Adding start position of the substring (' + startPos + ') to the results.');
+				stringTracer._select (startPos)._wait ();
+			}
+			else {
+				stringTracer._deselect (j)._wait ();
+				logger._print ('But j (' + j + ') does not equal length of substring (' + substr.length + ') Incrementing j and moving forward.');
+				j++;
+				logger._print ('j = ' + j);
+				stringTracer._select (j)._wait ();
+			}
+		}
+		else {
+			var tempJ = j - 1;
+			logger._print ('they\'re NOT equal');
+			trackTracer._select (tempJ)._wait ();
+			stringTracer._deselect (j)._wait ();
+
+			j = track [(j-1).mod (substr.length)];	//use modulo to wrap around, i.e., if index = -1, access the LAST element of array (PYTHON-LIKE)
+
+			logger._print ('Setting j to ' + j);
+			stringTracer._select (j)._wait ();
+			trackTracer._deselect (tempJ)._wait ();
+		}
+
+		stringTracer._deselect (i)._wait ();
+	}
+
+	return positions;
+}
+
+var positions = kmp (string, substring);
+
+logger._print ('Substring positions are: ' + (positions.length ? String (positions) : 'NONE'));
+for (var i = 0; i < positions.length; i++) {
+	stringTracer._select (positions [i], positions [i] + substring.length - 1)._wait ();
+}
diff --git a/algorithm/string/knuth_morris_pratt/substring_search/data.js b/algorithm/string/knuth_morris_pratt/substring_search/data.js
@@ -0,0 +1,20 @@
+function randString (length) {
+	var result = Math.random ().toString (36);
+	return result.substring (result.length - length);
+}
+
+var string = randString (15), substring = randString (5);
+//var string = 'abcxabcdabxabcdabcdabxabcda', substring = 'xabcda';
+//var string = 'abcxabcdabxabcdabcdabcyiuhsiuhduiahdubhbuuabcdabcysbhbh', substring = 'abcdabcy';
+
+var track = Array.apply (null, Array (substring.length)).map (Number.prototype.valueOf, 0);
+
+var logger = new LogTracer ();
+var trackTracer = new Array1DTracer (),
+	substrTracer = new Array1DTracer (),
+	stringTracer = new Array1DTracer ();
+
+
+trackTracer._setData (track);
+substrTracer._setData (substring);
+stringTracer._setData (string);
diff --git a/js/module/directed_graph.js b/js/module/directed_graph.js
@@ -111,7 +111,7 @@ DirectedGraphTracer.prototype = $.extend(true, Object.create(Tracer.prototype),
 
         var wgap = 1 / (maxDepth - 1);
         var dfs = function (node, depth, top, bottom) {
-            place(node, depth * wgap, (top + bottom) / 2);
+            place(node, top + bottom, depth * wgap);
             var children = 0;
             for (var i = 0; i < G[node].length; i++) {
                 if (G[node][i]) children++;
diff --git a/js/script.js b/js/script.js
@@ -239,11 +239,11 @@ $.getJSON('./algorithm/category.json', function (data) {
     for (var category in list) {
         (function (category) {
             var $category = $('<button class="category">')
-                .append('<i class="fa fa-fw fa-caret-down">')
+                .append('<i class="fa fa-fw fa-caret-right">')
                 .append(list[category].name);
             $category.click(function () {
                 $('[data-category="' + category + '"]').toggleClass('collapse');
-                $(this).find('i.fa').toggleClass('fa-caret-down fa-caret-right');
+                $(this).find('i.fa').toggleClass('fa-caret-right fa-caret-down');
             });
             $('#list').append($category);
             var subList = list[category].list;

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"Knapsack Problem": "Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible.",`
`3`	`3`	`"Complexity": {`
`4`		`- "time": "O(n<sup>2</sup>",`
	`4`	`+ "time": "O(n<sup>2</sup>)",`
`5`	`5`	`"space": "O(n<sup>2</sup>)"`
`6`	`6`	`},`
`7`	`7`	`"References": [`