New code

Author: codeztech-atique

Datastructure/BinaryTree/index.js

@@ -64,13 +64,12 @@ class BinarySearchTree {
       return currentNode.value;
    }
 
-   // hightOfBinaryTree() {
-   //    // Rules b = (n-1)/2
-   //    let totalNodes = this.count;
-   //    let height = Math.floor((totalNodes - 1) / 2); 
-   //    return height;
-   // }
-   
+   hightOfBinaryTree() {
+      // Rules b = (n-1)/2
+      let totalNodes = this.count;
+      let height = Math.floor((totalNodes - 1) / 2); 
+      return height;
+   }
    lookup(value) {
       let currentNode = this.root;
       while(currentNode) {

Datastructure/BinaryTree/practice.js

@@ -32,13 +32,15 @@ class Node {
    }
 }
 class BinarySearchTree {
+   
    constructor(value) {
-      this.root = new Node(value);
-      this.count = 1;
+       this.root = new Node(value);
+       this.length = 1;
    }
-
+    
    insert(value) {
       let newNode = new Node(value);
+
       let traverse = node => {
          if(value < node.value) {
             if(!node.left) {
@@ -54,11 +56,8 @@ class BinarySearchTree {
             }
          }
       }
-      traverse(this.root);
-   }
 
-   size() {
-      return this.count;
+      traverse(this.root);
    }
 
    min() {
@@ -83,14 +82,18 @@ class BinarySearchTree {
          if(value === currentNode.value) {
             return true;
          } else if(value < currentNode.value) {
-            currentNode = currentNode.left
+            currentNode = currentNode.left;
          } else {
             currentNode = currentNode.right;
          }
       }
       return false;
    }
 
+   size() {
+      return this.length;
+   }
+
    dfsInorder() {
       // left, middle, right
       //        10
@@ -101,12 +104,12 @@ class BinarySearchTree {
       //  / \       
       // 2   4 
 
-      // Output = 1,5,6,10,17,19,21
+      // Output = 2,3,4,5,6,10,17,19,21
       let result = [];
       let searchTree = node => {
          if(node.left) searchTree(node.left);
          result.push(node.value);
-         if(node.right) searchTree(node.right)
+         if(node.right) searchTree(node.right);
       }
       searchTree(this.root);
       return result;
@@ -124,7 +127,7 @@ class BinarySearchTree {
       let searchTree = node => {
          result.push(node.value);
          if(node.left) searchTree(node.left);
-         if(node.right) searchTree(node.right)
+         if(node.right) searchTree(node.right);
       }
       searchTree(this.root);
       return result;
@@ -161,9 +164,12 @@ class BinarySearchTree {
       while(queue.length) {
          let currentNode = queue.shift();
          result.push(currentNode.value);
+
          if(currentNode.left) {
             queue.push(currentNode.left);
-         } if(currentNode.right) {
+         }
+
+         if(currentNode.right) {
             queue.push(currentNode.right);
          }
       }
@@ -199,13 +205,13 @@ class BinarySearchTree {
 // bst.insert('S')
 // bst.insert('K')
 
-// const bst = new BinarySearchTree(4)
-// bst.insert(2)
-// bst.insert(7)
-// bst.insert(1)
-// bst.insert(3)
-// bst.insert(6)
-// bst.insert(9)
+const bst = new BinarySearchTree(4)
+bst.insert(2)
+bst.insert(7)
+bst.insert(1)
+bst.insert(3)
+bst.insert(6)
+bst.insert(9)
 
 
 console.log("BST Min: ",bst.min());
@@ -233,47 +239,20 @@ function getLeafCountOfBinaryTree(node) {
    if(node.left == null && node.right == null) return 1;
    return getLeafCountOfBinaryTree(node.left) + getLeafCountOfBinaryTree(node.right);
 }
-
-
-
-
-// function getLeafCountOfBinaryTree(node) {
-//    if(node == null) return 0;
-//    if(node.left == null && node.right == null) return 1;
-//    return getLeafCountOfBinaryTree(node.left) + getLeafCountOfBinaryTree(node.right);
-// }
-
 console.log("COUNT LEAF NODE: ", getLeafCountOfBinaryTree(bst.root));
 
-
 function hightOfBinaryTree(node) {
    if(node == null) {
       return 0;
    } else {
       let lTree = hightOfBinaryTree(node.left);
-      let RTree = hightOfBinaryTree(node.right);
-      if(lTree < RTree) {
+      let rTree = hightOfBinaryTree(node.right);
+      if(lTree > rTree) {
          return lTree + 1;
       } else {
-         return RTree + 1;
+         return rTree + 1;
       }
    }
 }
 
-
-
-
-// function hightOfBinaryTree(node) {
-//    if(node == null) {
-//       return 0;
-//    } else {
-//       let lTree = hightOfBinaryTree(node.left);
-//       let RTree = hightOfBinaryTree(node.right);
-//       if(lTree < RTree) {
-//          return lTree + 1;
-//       } else {
-//          return RTree + 1;
-//       }
-//    }
-// }
 console.log("HIGHT OF BINARY TREE: ", hightOfBinaryTree(bst.root));

Datastructure/Graphs/practice.js

@@ -1,18 +1,21 @@
 class UndirectedGraph {
-   constructor() {
-     this.noOfEdges = 0;
-     this.adjecentList = {};
-   }
-   addVertices(node) {
-     this.adjecentList[node] = [];
-   }
-   addEdges(node1, node2) {
-     this.adjecentList[node1].push(node2);
-     this.adjecentList[node2].push(node1);
-   }
-   showConnections() {
-     console.log(this.adjecentList);
-   }
+    constructor() {
+      this.noOfEdges = 0;
+      this.adjacentList = {};
+    }
+
+    addVertices(node) {
+      this.adjacentList[node] = [];
+    }
+
+    addEdges(node1, node2) {
+      this.adjacentList[node1].push(node2);
+      this.adjacentList[node2].push(node1);
+    }
+    
+    showConnections() {
+      return console.log(this.adjacentList);
+    }
 }
 const undirectedGrph = new UndirectedGraph();
 undirectedGrph.addVertices('0');

Datastructure/LinkedList/practice.js

@@ -45,51 +45,47 @@ class SinglyLinkedList {
       this.tail = this.head;
       this.length = 1;
    }
-   prepand(value) {
+   append(value) {
       let newNode = new Node(value);
       newNode.next = this.head;
-      this.head.prev = newNode; // for doubly linkedList
+      this.head.prev = newNode; // Doubly LinkedList
       this.head = newNode;
       this.length++;
       return this;
    }
-   append(value) {
+   prepand(value) {
       let newNode = new Node(value);
-      newNode.prev = this.tail; // for doubly linkedList
       this.tail.next = newNode;
+      newNode.prev = this.tail; // Doubly LinkedList
       this.tail = newNode;
       this.length++;
       return this;
    }
-   insert(index, value) {
+   insert(value, index) {
       if(index >= this.length) {
          return this.append(value);
       }
       let newNode = new Node(value);
-      let leader = this.traverse(index - 1);
-      let nextNode = leader.next;
-      leader.next = newNode;
-      newNode.prev = leader; // for doubly linkedList
+      let leaderNode = this.traverse(index - 1);
+      let nextNode = leaderNode.next;
+      leaderNode.next = newNode;
+      newNode.prev = leaderNode; // Doubly LinkedList
       newNode.next = nextNode;
-      nextNode.prev = newNode // for doubly linkedList
+      nextNode.prev = newNode; // Doubly LinkedList
+      this.length++;
       return this.printList();
    }
-
    remove(index) {
       if(index > this.length) {
-         return "Not possible !!!";
-      } 
-      let leader = this.traverse(index - 1);
-      let unwantedNode = leader.next;
-      leader.next = unwantedNode.next;
+         return "Invalid Input !!!"
+      }
+      let leaderNode = this.traverse(index - 1);
+      let unwantedNode = leaderNode.next;
+      leaderNode.next = unwantedNode.next;
       this.length--;
       return this.printList();
    }
-
    reverse() {
-      if(!this.head.next) {
-        return this.head;
-      }
       this.tail = this.head;
       let first = this.head;
       let second = first.next;
@@ -103,13 +99,12 @@ class SinglyLinkedList {
       this.head = first;
       return this.printList();
    }
-
    traverse(index) {
+      let count = 0;
       let currentNode = this.head;
-      let counter = 0;
-      while(index != counter) {
+      while(index != count) {
+         count++;
          currentNode = currentNode.next;
-         counter++;
       }
       return currentNode;
    }