few examples: change initial max value to infinity

64json · 64json · commit 65d0b1e0c209 · 2016-05-23T00:44:16.000-05:00
diff --git a/algorithm/graph_search/bfs/shortest_path/code.js b/algorithm/graph_search/bfs/shortest_path/code.js
@@ -27,7 +27,7 @@ var e; // e = start node
 do {
     e = Math.random() * G.length | 0;
 } while (s == e);
-var MAX_VALUE = 999;
+var MAX_VALUE = Infinity;
 tracer._pace(100);
 tracer._print('finding the shortest path from ' + s + ' to ' + e);
 tracer._sleep(1000);
diff --git a/algorithm/graph_search/dfs/shortest_path/code.js b/algorithm/graph_search/dfs/shortest_path/code.js
@@ -25,7 +25,7 @@ var e; // e = end node
 do {
     e = Math.random() * G.length | 0;
 } while (s == e);
-var MAX_VALUE = 999;
+var MAX_VALUE = Infinity;
 var minWeight = MAX_VALUE;
 tracer._pace(100);
 tracer._print('finding the shortest path from ' + s + ' to ' + e);
diff --git a/algorithm/graph_search/dijkstra/shortest_path/code.js b/algorithm/graph_search/dijkstra/shortest_path/code.js
@@ -1,42 +1,43 @@
-function Dijkstra(start, end){
-   tracer._sleep(333)
-   var minIndex, minDistance;
-   var S = []; // S[i] returns the distance from node v to node start
-   var D = []; // D[i] indicates whether the i-th node is discovered or not
-   for (var i = 0; i < G.length; i++){
-      D.push(false);
-      S[i] = 19990719 // Some big distance (infinity) 
-   }
-   S[start] = 0; // Starting node is at distance 0 from itself
-   for(var k = 0; k < G.length; k++){
-      // Finding a node with the shortest distance from S[minIndex]
-      minDistance = 19990719 // Some big distance (infinity)
-      for(i = 0; i < G.length; i++){
-         if(S[i] < minDistance && !D[i]){
-            minDistance = S[i];
-            minIndex = i;         
-         }
-      }
-      tracer._visit(minIndex,undefined);
-      tracer._sleep(500);
-      D[minIndex] = true;
-      if(minDistance == 19990719){ // If the distance is big (infinity), there is no more paths
-         tracer._print('there is no path from ' + s + ' to ' + e);
-         return false;
-      }
-      // For every unvisited neighbour of current node, we check
-      // whether the path to it is shorter if going over the current node 
-      for(i = 0; i < G.length; i++){
-         if (G[minIndex][i] && !D[i] && ( S[i] > S[minIndex] + G[minIndex][i])){
-            S[i] = S[minIndex] + G[minIndex][i];
-            tracer._visit(i,minIndex,S[i]);
-            tracer._sleep(500);
-            tracer._leave(i,minIndex,S[i]);
-         }
-      }
-      tracer._leave(minIndex,undefined);
-   }
-   tracer._print('the shortest path from ' + s + ' to ' + e + ' is ' + S[e]);
+function Dijkstra(start, end) {
+    tracer._sleep(333);
+    var MAX_VALUE = Infinity;
+    var minIndex, minDistance;
+    var S = []; // S[i] returns the distance from node v to node start
+    var D = []; // D[i] indicates whether the i-th node is discovered or not
+    for (var i = 0; i < G.length; i++) {
+        D.push(false);
+        S[i] = MAX_VALUE;
+    }
+    S[start] = 0; // Starting node is at distance 0 from itself
+    for (var k = 0; k < G.length; k++) {
+        // Finding a node with the shortest distance from S[minIndex]
+        minDistance = MAX_VALUE;
+        for (i = 0; i < G.length; i++) {
+            if (S[i] < minDistance && !D[i]) {
+                minDistance = S[i];
+                minIndex = i;
+            }
+        }
+        tracer._visit(minIndex, undefined);
+        tracer._sleep(500);
+        D[minIndex] = true;
+        if (minDistance == MAX_VALUE) { // If the distance is infinity, there is no more paths
+            tracer._print('there is no path from ' + s + ' to ' + e);
+            return false;
+        }
+        // For every unvisited neighbour of current node, we check
+        // whether the path to it is shorter if going over the current node
+        for (i = 0; i < G.length; i++) {
+            if (G[minIndex][i] && !D[i] && ( S[i] > S[minIndex] + G[minIndex][i])) {
+                S[i] = S[minIndex] + G[minIndex][i];
+                tracer._visit(i, minIndex, S[i]);
+                tracer._sleep(500);
+                tracer._leave(i, minIndex, S[i]);
+            }
+        }
+        tracer._leave(minIndex, undefined);
+    }
+    tracer._print('the shortest path from ' + s + ' to ' + e + ' is ' + S[e]);
 }
 
 var s = Math.random() * G.length | 0; // s = start node
diff --git a/algorithm/graph_search/floyd_warshall/shortest_paths/code.js b/algorithm/graph_search/floyd_warshall/shortest_paths/code.js
@@ -1,34 +1,35 @@
-function FloydWarshall(){
-  // Finds the shortest path between all nodes
-  var S = new Array(G.length);
-  for (var i = 0; i < G.length; i++) S[i] = new Array(G.length)
-  for (i = 0; i < G.length; i++){
-    tracer._visit(i)
-    for (var j = 0; j < G.length; j++){
-      // Distance to self is always 0
-      if (i==j) S[i][i] = 0;
-      // Distance between connected nodes is their weight
-      else if (G[i][j] > 0){ 
-        S[i][j] = G[i][j];
-        tracer._visit(j,i,S[i][j]);
-        tracer._leave(j,i,S[i][j]);
-      }// Else we don't know the distnace and we set it to a big value (infinity)
-      else S[i][j] = 19990719; 
+function FloydWarshall() {
+    // Finds the shortest path between all nodes
+    var S = new Array(G.length);
+    for (var i = 0; i < G.length; i++) S[i] = new Array(G.length)
+    for (i = 0; i < G.length; i++) {
+        tracer._visit(i)
+        for (var j = 0; j < G.length; j++) {
+            // Distance to self is always 0
+            if (i == j) S[i][i] = 0;
+            // Distance between connected nodes is their weight
+            else if (G[i][j] > 0) {
+                S[i][j] = G[i][j];
+                tracer._visit(j, i, S[i][j]);
+                tracer._leave(j, i, S[i][j]);
+            }// Else we don't know the distance and we set it to infinity
+            else S[i][j] = MAX_VALUE;
+        }
+        tracer._leave(i)
     }
-    tracer._leave(i)
-  }
-  // If there is a shorter path using k, use it instead
-  for (var k = 0; k < G.length; k++)
-      for (i = 0; i < G.length; i++)
+    // If there is a shorter path using k, use it instead
+    for (var k = 0; k < G.length; k++)
+        for (i = 0; i < G.length; i++)
+            for (j = 0; j < G.length; j++)
+                if (S[i][j] > S[i][k] + S[k][j])
+                    S[i][j] = S[i][k] + S[k][j];
+    for (i = 0; i < G.length; i++)
         for (j = 0; j < G.length; j++)
-          if (S[i][j] > S[i][k] + S[k][j])
-            S[i][j] = S[i][k] + S[k][j];
-  for (i = 0; i < G.length; i++)
-    for (j = 0; j < G.length; j++)
-      if(S[i][j] == 19990719) tracer._print('there is no path from ' + i + ' to ' + j);
-      else tracer._print('the shortest path from ' + i + 
-                         ' to ' + j + ' is ' + S[i][j]);
+            if (S[i][j] == MAX_VALUE) tracer._print('there is no path from ' + i + ' to ' + j);
+            else tracer._print('the shortest path from ' + i +
+                ' to ' + j + ' is ' + S[i][j]);
 }
+var MAX_VALUE = Infinity;
 tracer._pace(200);
 tracer._print('finding the shortest paths from and to all nodes');
 FloydWarshall();
diff --git a/algorithm/sorting/merge/basic/code.js b/algorithm/sorting/merge/basic/code.js
@@ -59,7 +59,7 @@ mergeSort.merge = function(start, middle, end) {
         i++;
     }
 
-    tempArray = [];
+    var tempArray = [];
     for (i = start; i < end; i++) tempArray.push(D[i]);
     tracer._print('merged array = [' + tempArray.join(', ') + ']');
 };

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ mergeSort.merge = function(start, middle, end) {`
`59`	`59`	`i++;`
`60`	`60`	`}`
`61`	`61`
`62`		`- tempArray = [];`
	`62`	`+ var tempArray = [];`
`63`	`63`	`for (i = start; i < end; i++) tempArray.push(D[i]);`
`64`	`64`	`tracer._print('merged array = [' + tempArray.join(', ') + ']');`
`65`	`65`	`};`