Removed node collection dependecy from consumed app

rajraku · rajraku · commit 274ec6312911 · 2017-02-27T14:51:22.000+05:30
udpated code to store nodeCollection and root with in the construct
tracer
diff --git a/algorithm/tree/binary_search_tree/bst_insert/code.js b/algorithm/tree/binary_search_tree/bst_insert/code.js
@@ -1,34 +1,32 @@
-function bst_insert ( root, element, parent ) { // node = current node , parent = previous node
+function bst_insert ( root, element, parent ) { // root = current node , parent = previous node
     tracer._visit ( root, parent )._wait ();
+    var treeNode = T[root];
+    var propName = '';    
     if ( element < root ) {
-        if ( T[root][0] === -1 ) {  // insert as left child of root
-            T[root][0] = element;
-            G[root][element] = 1; // update in graph
-            tracer._visit ( element, root )._wait ();
+        propName = 'left';
+    } else if ( element > root) {
+        propName = 'right';
+    }
+    if(propName !== '') {
+        if ( !treeNode.hasOwnProperty(propName) ) {  // insert as left child of root
+            treeNode[propName] = element;
+            T[element] = {};
+            tracer._addNode(element, root);
             logger._print( element + ' Inserted ');
         } else {
-            //tracer._clear ();
-            bst_insert ( T[root][0], element, root );
-        }
-    } else if ( element > root ) { // insert as right child of root
-        if( T[root][1] === -1 ) {
-            T[root][1] = element;
-            G[root][element] = 1; // update in graph
-            tracer._visit ( element, root )._wait ();
-            logger._print ( element + ' Inserted ');
-        } else {
-            //tracer._clear ();
-            bst_insert ( T[root][1], element, root );
+            bst_insert ( treeNode[propName], element, root );
         }
     }
 }
 
 var Root = elements[0]; // take first element as root
+T[Root] = {};
+tracer._addRoot(Root);
 logger._print ( Root + ' Inserted as root of tree ');
-tracer._setTreeData ( G, Root );
 
 for (var i = 1; i < elements.length; i++) {
     tracer2._select ( i )._wait();
     bst_insert ( Root, elements[i] ); // insert ith element
     tracer2._deselect( i );
+    tracer.clear();
 }
diff --git a/algorithm/tree/binary_search_tree/bst_insert/data.js b/algorithm/tree/binary_search_tree/bst_insert/data.js
@@ -1,10 +1,7 @@
-var G = [];
-
-
 var T = {};
 
 var elements = [5,8,10,3,1,6,9,7,2,0,4]; // item to be searched
-var tracer = new DirectedGraphTracer( " BST - Elements marked red indicates the current status of tree ");
+var tracer = new DirectedGraphConstructTracer( " BST - Elements marked red indicates the current status of tree ", 0);
 var tracer2 = new Array1DTracer ( " Elements ")._setData ( elements );
 var logger = new LogTracer ( " Log ");
 tracer.attach ( logger );
diff --git a/js/module/tracer/directed_graph_construct.js b/js/module/tracer/directed_graph_construct.js
@@ -14,19 +14,29 @@ class DirectedGraphConstructTracer extends Tracer {
   constructor(name, nodePlacement = null) {
     super(name);
     this.nodePlacement = nodePlacement;
+    this.nodeCollection = [];
     if (this.isNew) initView(this);
   }
 
-  _addNode(G, root, element, parentElement = null) {
+  _addRoot(root) {
+    this.manager.pushStep(this.capsule, {
+      type: 'addRoot',
+      arguments: arguments
+    });
+    return this;
+  }
+
+  _addNode(element, parentElement = null) {
     this.manager.pushStep(this.capsule, {
       type: 'addNode',
       arguments: arguments
     });
     return this;
   }
 
-  _findNode(G, val) {
+  _findNode(val) {
     var idToFind = this.n(val);
+    var G = this.nodeCollection;
     var result = null;
     for (let i = 0; i < G.length; i++) {
       if(G[i].id === idToFind) {
@@ -37,10 +47,9 @@ class DirectedGraphConstructTracer extends Tracer {
     return result;
   }
 
-  _visit(G, target, source) {
+  _visit(target, source) {
     this.manager.pushStep(this.capsule, {
       type: 'visit',
-      G: G,
       target: target,
       source: source
     });
@@ -77,13 +86,16 @@ class DirectedGraphConstructTracer extends Tracer {
           node.y = position.y;
         });
         break;
+      case 'addRoot':
+        this.addRoot.apply(this, step.arguments);
+        break;
       case 'addNode':
         this.addNode.apply(this, step.arguments);
         break;
       case 'visit':
       case 'leave':
         var visit = step.type == 'visit';
-        var nodeObject = this._findNode(step.G, step.target);
+        var nodeObject = this._findNode(step.target);
         nodeObject.visited = visit;
         nodeObject.isNew = false;
         var targetNode = this.graph.nodes(this.n(step.target));
@@ -108,9 +120,20 @@ class DirectedGraphConstructTracer extends Tracer {
     }
   }
 
-  addNode(G, root, node, parent) {
+  addRoot(root) {
+    if(this.rootObject) throw 'Root for this graph is already added';
+    this.rootObject = this.createGraphNode(root);
+    this.drawGraph(this.rootObject.level);
+  }
+
+  addNode(node, parent) {
+    var nodeObject = this.createGraphNode(node, parent)
+    this.drawGraph(nodeObject.level);
+  }
+
+  createGraphNode(node, parent) {
     var nodeObject = this.nodeConstruct(node);
-    var parentObject = this._findNode(G, parent);
+    var parentObject = this._findNode(parent);
     if (parentObject) {
       nodeObject.parent = parentObject;
       nodeObject.level = parentObject.level + 1;
@@ -131,18 +154,14 @@ class DirectedGraphConstructTracer extends Tracer {
         }
         if(isSpliced) {
           parentObject.children.splice(insertIndex, 0, nodeObject);
-          console.log('exchange Happened');
         } else {
           parentObject.children.push(nodeObject);
         }
       }
     }
     nodeObject.updateBreadth();
-    G.push(nodeObject);
-    this.drawGraph(G, root, nodeObject.level);
-    if(node === 4) {
-      console.log(this.graph.nodes);
-    }
+    this.nodeCollection.push(nodeObject);
+    return nodeObject;
   }
 
   nodeConstruct(val) {
@@ -171,7 +190,7 @@ class DirectedGraphConstructTracer extends Tracer {
     return nodeObject;
   }
   
-  drawGraph(G, root, nodeLevel) {
+  drawGraph(nodeLevel) {
     const nodes = [];
     const edges = [];
     var tracer = this;
@@ -210,9 +229,8 @@ class DirectedGraphConstructTracer extends Tracer {
           occupiedBreadth += node.breadth;
         }
       }
-    }
-    var rootObject = this._findNode(G, root);
-    drawNode(rootObject);
+    };
+    drawNode(this.rootObject);
     
     this.graph.clear();
     this.graph.read({
@@ -251,8 +269,10 @@ class DirectedGraphConstructTracer extends Tracer {
   }
 
   clearGraphColor() {
-    var tracer = this;
-
+    this.nodeCollection.forEach(function(node){
+      node.isNew = false;
+    });
+    
     this.graph.nodes().forEach(function (node) {
       node.color = tracer.color.default;
     });
