minor

64json · 64json · commit ee9e4d948acc · 2016-05-24T20:41:44.000-05:00
diff --git a/algorithm/etc/dp/fibonacci/code.js b/algorithm/etc/dp/fibonacci/code.js
@@ -1,7 +1,7 @@
 for (var i = 2; i < index; i++) {
     D[i] = D[i - 2] + D[i - 1];
-    tracer._select(i - 2, i - 1)._next();
-    tracer._notify(i, D[i])._next();
+    tracer._select(i - 2, i - 1)._wait();
+    tracer._notify(i, D[i])._wait();
     tracer._denotify(i);
     tracer._deselect(i - 2, i - 1);
 }
diff --git a/algorithm/etc/dp/longest_increasing_subsequence/code.js b/algorithm/etc/dp/longest_increasing_subsequence/code.js
@@ -9,7 +9,7 @@ for (var i = 1; i < 10; i++) {
     tracer._select(i);
     logger._print(' LIS[' + i + '] = ' + LIS[i]);
     for (var j = 0; j < i; j++) {
-        tracer._notify(j)._next();
+        tracer._notify(j)._wait();
         tracer._denotify(j);
         if (A[i] > A[j] && LIS[i] < LIS[j] + 1) {
             LIS[i] = LIS[j] + 1;
diff --git a/algorithm/etc/dp/max_sum_path/code.js b/algorithm/etc/dp/max_sum_path/code.js
@@ -2,8 +2,8 @@ var N = DP.length;
 var M = DP[0].length;
 function update(i, j, value) {
     DP[i][j] = value;
-    dataViewer._select(i, j)._next();
-    tracer._notify(i, j, DP[i][j])._next();
+    dataViewer._select(i, j)._wait();
+    tracer._notify(i, j, DP[i][j])._wait();
     tracer._denotify(i, j);
     dataViewer._deselect(i, j);
 }
diff --git a/algorithm/etc/dp/sliding_window/code.js b/algorithm/etc/dp/sliding_window/code.js
@@ -1,13 +1,13 @@
 var sum = D[0] + D[1] + D[2];
 var max = sum;
 tracer._select(0, 2);
-logger._print('sum = ' + sum)._next();
+logger._print('sum = ' + sum)._wait();
 for (var i = 3; i < D.length; i++) {
     sum += D[i] - D[i - 3];
     if (max < sum) max = sum;
     tracer._deselect(i - 3);
     tracer._select(i);
-    logger._print('sum = ' + sum)._next();
+    logger._print('sum = ' + sum)._wait();
 }
-tracer._next()._deselect(D.length - 3, D.length - 1);
+tracer._deselect(D.length - 3, D.length - 1);
 logger._print('max = ' + max);
diff --git a/algorithm/graph_search/bellman_ford/shortest_path/code.js b/algorithm/graph_search/bellman_ford/shortest_path/code.js
@@ -20,14 +20,14 @@ function BELLMAN_FORD(src, dest) {
         for (var currentNode = 0; currentNode < G.length; currentNode++) {
             for (var currentNodeNeighbor = 0; currentNodeNeighbor <= G.length; currentNodeNeighbor++) {
                 if (G [currentNode] [currentNodeNeighbor]) {	//proceed to relax Edges only if a particular weight != 0 (0 represents no edge)
-                    logger._next()._print('Exploring edge from ' + currentNode + ' to ' + currentNodeNeighbor + ', weight = ' + G [currentNode] [currentNodeNeighbor]);
+                    logger._print('Exploring edge from ' + currentNode + ' to ' + currentNodeNeighbor + ', weight = ' + G [currentNode] [currentNodeNeighbor]);
 
                     if (weights [currentNodeNeighbor] > (weights [currentNode] + G [currentNode] [currentNodeNeighbor])) {
                         weights [currentNodeNeighbor] = weights [currentNode] + G [currentNode] [currentNodeNeighbor];
                         logger._print('weights [' + currentNodeNeighbor + '] = weights [' + currentNode + '] + ' + G [currentNode] [currentNodeNeighbor]);
                     }
-                    tracer._visit(currentNodeNeighbor, currentNode, weights [currentNodeNeighbor]);
-                    tracer._next()._leave(currentNodeNeighbor, currentNode);
+                    tracer._visit(currentNodeNeighbor, currentNode, weights [currentNodeNeighbor])._wait();
+                    tracer._leave(currentNodeNeighbor, currentNode)._wait();
                 }
             }
         }
diff --git a/algorithm/graph_search/bfs/shortest_path/code.js b/algorithm/graph_search/bfs/shortest_path/code.js
@@ -8,15 +8,15 @@ function BFS() {
     }
     W[s] = 0;
     Q.push(s); // add start node to queue
-    tracer._visit(s, undefined, 0);
+    tracer._visit(s, undefined, 0)._wait();
     while (Q.length > 0) {
         var node = Q.shift(); // dequeue
         for (i = 0; i < G[node].length; i++) {
             if (G[node][i]) { // if the edge from current node to the i-th node exists
                 if (W[i] > W[node] + G[node][i]) { // if current path is shorter than the previously shortest path
                     W[i] = W[node] + G[node][i]; // update the length of the shortest path
                     Q.push(i); // add child node to queue
-                    tracer._next()._visit(i, node, W[i]);
+                    tracer._visit(i, node, W[i])._wait();
                 }
             }
         }
diff --git a/algorithm/graph_search/bfs/tree/code.js b/algorithm/graph_search/bfs/tree/code.js
@@ -1,13 +1,13 @@
 function BFS(s) { // s = start node
     var Q = [];
     Q.push(s); // add start node to queue
-    tracer._visit(s);
+    tracer._visit(s)._wait();
     while (Q.length > 0) {
         var node = Q.shift(); // dequeue
         for (var i = 0; i < G[node].length; i++) {
             if (G[node][i]) { // if current node has the i-th node as a child
                 Q.push(i); // add child node to queue
-                tracer._next()._visit(i, node);
+                tracer._visit(i, node)._wait();
             }
         }
     }
diff --git a/algorithm/graph_search/dfs/all_paths/code.js b/algorithm/graph_search/dfs/all_paths/code.js
@@ -1,5 +1,5 @@
 function DFS(node, parent) { // node = current node, parent = previous node
-    tracer._next()._visit(node, parent);
+    tracer._visit(node, parent)._wait();
     D[node] = true; // label current node as discovered
     for (var i = 0; i < G[node].length; i++) {
         if (G[node][i]) { // if the edge from current node to the i-th node exists
@@ -9,7 +9,7 @@ function DFS(node, parent) { // node = current node, parent = previous node
         }
     }
     D[node] = false; // label current node as undiscovered
-    tracer._next()._leave(node, parent);
+    tracer._leave(node, parent)._wait();
 }
 var D; // D[i] indicates whether the i-th node is discovered or not
 for (var i = 0; i < G.length; i++) { // start from every node
diff --git a/algorithm/graph_search/dfs/shortest_path/code.js b/algorithm/graph_search/dfs/shortest_path/code.js
@@ -1,15 +1,15 @@
 function DFS(node, parent, weight) { // node = current node, parent = previous node
     if (minWeight < weight) return;
     if (node == e) {
-        tracer._next()._visit(node, parent, weight);
-        tracer._next()._leave(node, parent, 0);
+        tracer._visit(node, parent, weight)._wait();
+        tracer._leave(node, parent, 0)._wait();
         if (minWeight > weight) {
             minWeight = weight;
         }
         return;
     }
     D[node] = true; // label current node as discovered
-    tracer._next()._visit(node, parent, weight);
+    tracer._visit(node, parent, weight)._wait();
     for (var i = 0; i < G[node].length; i++) {
         if (G[node][i]) { // if the path from current node to the i-th node exists
             if (!D[i]) { // if the i-th node is not labeled as discovered
@@ -18,7 +18,7 @@ function DFS(node, parent, weight) { // node = current node, parent = previous n
         }
     }
     D[node] = false; // label current node as undiscovered
-    tracer._next()._leave(node, parent, 0);
+    tracer._leave(node, parent, 0)._wait();
 }
 var s = Math.random() * G.length | 0; // s = start node
 var e; // e = end node
diff --git a/algorithm/graph_search/dfs/tree/code.js b/algorithm/graph_search/dfs/tree/code.js
@@ -1,5 +1,5 @@
 function DFS(node, parent) { // node = current node, parent = previous node
-    tracer._next()._visit(node, parent);
+    tracer._visit(node, parent)._wait();
     for (var i = 0; i < G[node].length; i++) {
         if (G[node][i]) { // if current node has the i-th node as a child
             DFS(i, node); // recursively call DFS
diff --git a/algorithm/graph_search/dfs/weighted_graph/code.js b/algorithm/graph_search/dfs/weighted_graph/code.js
@@ -1,6 +1,6 @@
 function DFS(node, parent, weight) { // node = current node, parent = previous node
-    logger._next()._print((parent === undefined ? '' : parent) + ' -> ' + node);
-    tracer._visit(node, parent, weight);
+    logger._print((parent === undefined ? '' : parent) + ' -> ' + node);
+    tracer._visit(node, parent, weight)._wait();
     D[node] = true; // label current node as discovered
     for (var i = 0; i < G[node].length; i++) {
         if (G[node][i]) { // if the edge from current node to the i-th node exists
@@ -10,8 +10,8 @@ function DFS(node, parent, weight) { // node = current node, parent = previous n
         }
     }
     D[node] = false; // label current node as undiscovered
-    logger._next()._print(node + ' <- ' + (parent === undefined ? '' : parent));
-    tracer._leave(node, parent, 0);
+    logger._print(node + ' <- ' + (parent === undefined ? '' : parent));
+    tracer._leave(node, parent, 0)._wait();
 }
 var D; // D[i] indicates whether the i-th node is discovered or not
 for (var i = 0; i < G.length; i++) { // start from every node
diff --git a/algorithm/graph_search/dijkstra/shortest_path/code.js b/algorithm/graph_search/dijkstra/shortest_path/code.js
@@ -1,5 +1,4 @@
 function Dijkstra(start, end) {
-    tracer._next();
     var MAX_VALUE = Infinity;
     var minIndex, minDistance;
     var S = []; // S[i] returns the distance from node v to node start
@@ -21,17 +20,17 @@ function Dijkstra(start, end) {
         }
         if (minDistance == MAX_VALUE) break; // If there is no edge from current node, jump out of loop
         D[minIndex] = true;
-        tracer._next()._visit(minIndex);
+        tracer._visit(minIndex)._wait();
         // 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] && S[i] > S[minIndex] + G[minIndex][i]) {
                 S[i] = S[minIndex] + G[minIndex][i];
-                tracer._next()._visit(i, minIndex, S[i]);
-                tracer._next()._leave(i, minIndex, S[i]);
+                tracer._visit(i, minIndex, S[i])._wait();
+                tracer._leave(i, minIndex, S[i])._wait();
             }
         }
-        tracer._next()._leave(minIndex);
+        tracer._leave(minIndex)._wait();
     }
     if (S[end] == MAX_VALUE) {
         logger._print('there is no path from ' + start + ' to ' + end);
@@ -45,5 +44,5 @@ var e; // e = end node
 do {
     e = Math.random() * G.length | 0;
 } while (s == e);
-logger._print('finding the shortest path from ' + s + ' to ' + e);
+logger._print('finding the shortest path from ' + s + ' to ' + e)._wait();
 Dijkstra(s, e);
diff --git a/algorithm/graph_search/floyd_warshall/shortest_paths/code.js b/algorithm/graph_search/floyd_warshall/shortest_paths/code.js
@@ -3,19 +3,19 @@ function FloydWarshall() {
     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._next()._visit(i)
+        tracer._visit(i)._wait();
         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._next()._visit(j, i, S[i][j]);
-                tracer._next()._leave(j, i, S[i][j]);
+                tracer._visit(j, i, S[i][j])._wait();
+                tracer._leave(j, i, S[i][j])._wait();
             }// Else we don't know the distance and we set it to infinity
             else S[i][j] = MAX_VALUE;
         }
-        tracer._next()._leave(i)
+        tracer._leave(i)._wait();
     }
     // If there is a shorter path using k, use it instead
     for (var k = 0; k < G.length; k++)
diff --git a/algorithm/graph_search/topological_sort/kahn_algorithm/code.js b/algorithm/graph_search/topological_sort/kahn_algorithm/code.js
@@ -6,10 +6,10 @@
     for (var currNode = 0; currNode < G.length; currNode++) {
         for (var currNodeNeighbor = 0; currNodeNeighbor < G.length; currNodeNeighbor++) {
             if (G [currNode] [currNodeNeighbor]) {
-                logger._next()._print(currNodeNeighbor + ' has an incoming edge from ' + currNode);
-                tracer._visit(currNodeNeighbor, currNode);
+                logger._print(currNodeNeighbor + ' has an incoming edge from ' + currNode);
+                tracer._visit(currNodeNeighbor, currNode)._wait();
                 inDegrees [currNodeNeighbor]++;
-                tracer._next()._leave(currNodeNeighbor, currNode);
+                tracer._leave(currNodeNeighbor, currNode)._wait();
             }
         }
     }
@@ -18,36 +18,36 @@
 
     logger._print('Initializing queue with all the sources (nodes with no incoming edges)');
     inDegrees.map(function (indegrees, node) {
-        tracer._next()._visit(node);
+        tracer._visit(node)._wait();
         if (!indegrees) {
             logger._print(node + ' is a source');
             Q.push(node);
         }
-        tracer._next()._leave(node);
+        tracer._leave(node)._wait();
     });
     logger._print('Done. Initial State of Queue: [ ' + String(Q) + ' ]');
     logger._print('');
 
     //begin topological sort (kahn)
     while (Q.length > 0) {
-        logger._next()._print('Iteration #' + iter + '. Queue state: [ ' + String(Q) + ' ]');
+        logger._print('Iteration #' + iter + '. Queue state: [ ' + String(Q) + ' ]');
         currNode = Q.shift();
-        tracer._visit(currNode);
+        tracer._visit(currNode)._wait();
 
         for (i = 0; i < G.length; i++) {
             if (G [currNode] [i]) {
-                logger._next()._print(i + ' has an incoming edge from ' + currNode + '. Decrementing ' + i + '\'s in-degree by 1.');
-                tracer._visit(i, currNode);
+                logger._print(i + ' has an incoming edge from ' + currNode + '. Decrementing ' + i + '\'s in-degree by 1.');
+                tracer._visit(i, currNode)._wait();
                 inDegrees [i]--;
-                tracer._next()._leave(i, currNode);
+                tracer._leave(i, currNode)._wait();
 
                 if (!inDegrees [i]) {
                     logger._print(i + '\'s in-degree is now 0. Enqueuing ' + i);
                     Q.push(i);
                 }
             }
         }
-        tracer._next()._leave(currNode);
+        tracer._leave(currNode)._wait();
         logger._print('In-degrees are: [' + String(inDegrees) + ' ]');
         logger._print('-------------------------------------------------------------------');
 
diff --git a/algorithm/mst/prim/normal/code.js b/algorithm/mst/prim/normal/code.js
@@ -10,17 +10,17 @@ function prim() {
             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._next()._visit(i, j);
+                        tracer._visit(i, j)._wait();
                         // 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._next()._leave(i, j);
+                        tracer._leave(i, j)._wait();
                     }
-        tracer._next()._visit(minI, minJ);
+        tracer._visit(minI, minJ)._wait();
         D[minJ] = 1; // Visit second node and insert it into or tree
         sum += G[minI][minJ];
     }
diff --git a/algorithm/search/binary_search/iterative/code.js b/algorithm/search/binary_search/iterative/code.js
@@ -8,9 +8,9 @@ function BinarySearch(array, element) { // array = sorted array, element = eleme
         var middleIndex = Math.floor((minIndex + maxIndex) / 2);
         testElement = array[middleIndex];
 
-        tracer._select(minIndex, maxIndex)._next();
+        tracer._select(minIndex, maxIndex)._wait();
         tracer._notify(middleIndex);
-        logger._print('Searching at index: ' + middleIndex)._next();
+        logger._print('Searching at index: ' + middleIndex)._wait();
         tracer._denotify(middleIndex);
         tracer._deselect(minIndex, maxIndex);
 
diff --git a/algorithm/search/binary_search/recursive/code.js b/algorithm/search/binary_search/recursive/code.js
@@ -7,9 +7,9 @@ function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted ar
     var middleIndex = Math.floor((minIndex + maxIndex) / 2);
     var testElement = array[middleIndex];
 
-    tracer._select(minIndex, maxIndex)._next();
+    tracer._select(minIndex, maxIndex)._wait();
     tracer._notify(middleIndex);
-    logger._print('Searching at index: ' + middleIndex)._next();
+    logger._print('Searching at index: ' + middleIndex)._wait();
     tracer._denotify(middleIndex);
     tracer._deselect(minIndex, maxIndex);
 
diff --git a/algorithm/sorting/bubble/basic/code.js b/algorithm/sorting/bubble/basic/code.js
@@ -3,15 +3,15 @@ var N = D.length;
 var swapped;
 do {
     swapped = false;
-    tracer._select(N - 1)._next();
+    tracer._select(N - 1)._wait();
     for (var i = 1; i < N; i++) {
         if (D[i - 1] > D[i]) {
             logger._print('swap ' + D[i - 1] + ' and ' + D[i]);
             var temp = D[i - 1];
             D[i - 1] = D[i];
             D[i] = temp;
             swapped = true;
-            tracer._notify(i - 1, D[i - 1])._notify(i, D[i])._next();
+            tracer._notify(i - 1, D[i - 1])._notify(i, D[i])._wait();
             tracer._denotify(i - 1)._denotify(i);
         }
     }
diff --git a/algorithm/sorting/heap/basic/code.js b/algorithm/sorting/heap/basic/code.js
@@ -13,9 +13,9 @@ function heapSort(array, size) {
         array[j] = temp;
         
         tracer._notify(0, array[0])._notify(j, array[j]);
-        logger._print('Swapping elements : ' + array[0] + ' & ' + array[j])._next();
+        logger._print('Swapping elements : ' + array[0] + ' & ' + array[j])._wait();
         tracer._denotify(0)._denotify(j);
-        tracer._select(j)._next();
+        tracer._select(j)._wait();
 
         heapify(array, j, 0);
 
@@ -44,7 +44,7 @@ function heapify(array, size, root) {
         array[largest] = temp;
 
         tracer._notify(root, array[root])._notify(largest, array[largest]);
-        logger._print('Swapping elements : ' + array[root] + ' & ' + array[largest])._next();
+        logger._print('Swapping elements : ' + array[root] + ' & ' + array[largest])._wait();
         tracer._denotify(root)._denotify(largest);
 
         heapify(array, size, largest);
diff --git a/algorithm/sorting/insertion/basic/code.js b/algorithm/sorting/insertion/basic/code.js
@@ -2,15 +2,15 @@ logger._print('original array = [' + D.join(', ') + ']');
 for (var i = 1; i < D.length; i++) {
     var key = D[i];
     logger._print('insert ' + key);
-    tracer._select(i)._next();
+    tracer._select(i)._wait();
     var j;
     for (j = i - 1; (j >= 0) && (D[j] > key); j--) {
         D[j + 1] = D[j];
-        tracer._notify(j + 1, D[j + 1])._next();
+        tracer._notify(j + 1, D[j + 1])._wait();
         tracer._denotify(j + 1);
     }
     D[j + 1] = key;
-    tracer._notify(j + 1, D[j + 1])._next();
+    tracer._notify(j + 1, D[j + 1])._wait();
     tracer._denotify(j + 1);
     tracer._deselect(i);
 }
diff --git a/algorithm/sorting/merge/basic/code.js b/algorithm/sorting/merge/basic/code.js
diff --git a/algorithm/sorting/quick/basic/code.js b/algorithm/sorting/quick/basic/code.js
diff --git a/algorithm/sorting/selection/basic/code.js b/algorithm/sorting/selection/basic/code.js
diff --git a/algorithm/string/edit_distance/dynamic_programming/code.js b/algorithm/string/edit_distance/dynamic_programming/code.js
diff --git a/js/module/tracer.js b/js/module/tracer.js

Original file line number	Diff line number	Diff line change
`@@ -20,14 +20,14 @@ function BELLMAN_FORD(src, dest) {`
`20`	`20`	`for (var currentNode = 0; currentNode < G.length; currentNode++) {`
`21`	`21`	`for (var currentNodeNeighbor = 0; currentNodeNeighbor <= G.length; currentNodeNeighbor++) {`
`22`	`22`	`if (G [currentNode] [currentNodeNeighbor]) { //proceed to relax Edges only if a particular weight != 0 (0 represents no edge)`
`23`		`- logger._next()._print('Exploring edge from ' + currentNode + ' to ' + currentNodeNeighbor + ', weight = ' + G [currentNode] [currentNodeNeighbor]);`
	`23`	`+ logger._print('Exploring edge from ' + currentNode + ' to ' + currentNodeNeighbor + ', weight = ' + G [currentNode] [currentNodeNeighbor]);`
`24`	`24`
`25`	`25`	`if (weights [currentNodeNeighbor] > (weights [currentNode] + G [currentNode] [currentNodeNeighbor])) {`
`26`	`26`	`weights [currentNodeNeighbor] = weights [currentNode] + G [currentNode] [currentNodeNeighbor];`
`27`	`27`	`logger._print('weights [' + currentNodeNeighbor + '] = weights [' + currentNode + '] + ' + G [currentNode] [currentNodeNeighbor]);`
`28`	`28`	`}`
`29`		`- tracer._visit(currentNodeNeighbor, currentNode, weights [currentNodeNeighbor]);`
`30`		`- tracer._next()._leave(currentNodeNeighbor, currentNode);`
	`29`	`+ tracer._visit(currentNodeNeighbor, currentNode, weights [currentNodeNeighbor])._wait();`
	`30`	`+ tracer._leave(currentNodeNeighbor, currentNode)._wait();`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,15 +8,15 @@ function BFS() {`
`8`	`8`	`}`
`9`	`9`	`W[s] = 0;`
`10`	`10`	`Q.push(s); // add start node to queue`
`11`		`- tracer._visit(s, undefined, 0);`
	`11`	`+ tracer._visit(s, undefined, 0)._wait();`
`12`	`12`	`while (Q.length > 0) {`
`13`	`13`	`var node = Q.shift(); // dequeue`
`14`	`14`	`for (i = 0; i < G[node].length; i++) {`
`15`	`15`	`if (G[node][i]) { // if the edge from current node to the i-th node exists`
`16`	`16`	`if (W[i] > W[node] + G[node][i]) { // if current path is shorter than the previously shortest path`
`17`	`17`	`W[i] = W[node] + G[node][i]; // update the length of the shortest path`
`18`	`18`	`Q.push(i); // add child node to queue`
`19`		`- tracer._next()._visit(i, node, W[i]);`
	`19`	`+ tracer._visit(i, node, W[i])._wait();`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	`function BFS(s) { // s = start node`
`2`	`2`	`var Q = [];`
`3`	`3`	`Q.push(s); // add start node to queue`
`4`		`- tracer._visit(s);`
	`4`	`+ tracer._visit(s)._wait();`
`5`	`5`	`while (Q.length > 0) {`
`6`	`6`	`var node = Q.shift(); // dequeue`
`7`	`7`	`for (var i = 0; i < G[node].length; i++) {`
`8`	`8`	`if (G[node][i]) { // if current node has the i-th node as a child`
`9`	`9`	`Q.push(i); // add child node to queue`
`10`		`- tracer._next()._visit(i, node);`
	`10`	`+ tracer._visit(i, node)._wait();`
`11`	`11`	`}`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`function DFS(node, parent) { // node = current node, parent = previous node`
`2`		`- tracer._next()._visit(node, parent);`
	`2`	`+ tracer._visit(node, parent)._wait();`
`3`	`3`	`D[node] = true; // label current node as discovered`
`4`	`4`	`for (var i = 0; i < G[node].length; i++) {`
`5`	`5`	`if (G[node][i]) { // if the edge from current node to the i-th node exists`
`@@ -9,7 +9,7 @@ function DFS(node, parent) { // node = current node, parent = previous node`
`9`	`9`	`}`
`10`	`10`	`}`
`11`	`11`	`D[node] = false; // label current node as undiscovered`
`12`		`- tracer._next()._leave(node, parent);`
	`12`	`+ tracer._leave(node, parent)._wait();`
`13`	`13`	`}`
`14`	`14`	`var D; // D[i] indicates whether the i-th node is discovered or not`
`15`	`15`	`for (var i = 0; i < G.length; i++) { // start from every node`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,15 @@`
`1`	`1`	`function DFS(node, parent, weight) { // node = current node, parent = previous node`
`2`	`2`	`if (minWeight < weight) return;`
`3`	`3`	`if (node == e) {`
`4`		`- tracer._next()._visit(node, parent, weight);`
`5`		`- tracer._next()._leave(node, parent, 0);`
	`4`	`+ tracer._visit(node, parent, weight)._wait();`
	`5`	`+ tracer._leave(node, parent, 0)._wait();`
`6`	`6`	`if (minWeight > weight) {`
`7`	`7`	`minWeight = weight;`
`8`	`8`	`}`
`9`	`9`	`return;`
`10`	`10`	`}`
`11`	`11`	`D[node] = true; // label current node as discovered`
`12`		`- tracer._next()._visit(node, parent, weight);`
	`12`	`+ tracer._visit(node, parent, weight)._wait();`
`13`	`13`	`for (var i = 0; i < G[node].length; i++) {`
`14`	`14`	`if (G[node][i]) { // if the path from current node to the i-th node exists`
`15`	`15`	`if (!D[i]) { // if the i-th node is not labeled as discovered`
`@@ -18,7 +18,7 @@ function DFS(node, parent, weight) { // node = current node, parent = previous n`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`	`D[node] = false; // label current node as undiscovered`
`21`		`- tracer._next()._leave(node, parent, 0);`
	`21`	`+ tracer._leave(node, parent, 0)._wait();`
`22`	`22`	`}`
`23`	`23`	`var s = Math.random() * G.length \| 0; // s = start node`
`24`	`24`	`var e; // e = end node`