Add merge sort code

Author: codeztech-atique

.DS_Store

@@ -3,9 +3,33 @@
 // Time Complexity - O(n log(n))
 // Space Complexity - O(n)
 
+function merge(left, right) {
+    let arr = []
+    // Break out of loop if any one of the array gets empty
+    while (left.length && right.length) {
+        // Pick the smaller among the smallest element of left and right sub arrays 
+        if (left[0] < right[0]) {
+            arr.push(left.shift())  
+        } else {
+            arr.push(right.shift()) 
+        }
+    }
+    
+    // Concatenating the leftover elements
+    // (in case we didn't go through the entire left or right array)
+    return [ ...arr, ...left, ...right ]
+}
 
-const merge = (arr1, arr2) => {
+const mergeSort = (array) => {
+    const half = array.length / 2
 
+    // Base case or terminating case
+    if(array.length < 2){
+      return array 
+    }
+    
+    const left = array.splice(0, half);
+    return merge(mergeSort(left),mergeSort(array))
 };
 
-console.log(merge([2, 5, 3, 0, 57], [9, 12, 13]));
+console.log(mergeSort([2, 5, 3, 0, 57, 9, 12, 13]));

Algorithms/Sorting/mergeSort.js

@@ -0,0 +1,24 @@
+// Practice Merge Sort
+
+const mergeSort = (arr) => {
+    let half = arr.length / 2;
+    if(arr.length < 2) {
+        return arr;
+    }
+    let left = arr.splice(0, half);
+    return merge(mergeSort(left), mergeSort(arr));
+}
+
+const merge = (left, right) => {
+    let arr = [];
+    while(left.length && right.length) {
+       if(left[0] < right[0]) {
+           arr.push(left.shift());
+       } else {
+           arr.push(right.shift())
+       }
+    }
+    return [...arr, ...left, ...right]
+}
+
+console.log(mergeSort([2, 5, 3, 0, 57, 9, 12, 13]));

Algorithms/Sorting/practice.js

@@ -32,32 +32,33 @@ class Node {
    }
 }
 class BinarySearchTree {
-   
    constructor(value) {
-       this.root = new Node(value);
-       this.length = 1;
+      this.root = new Node(value);
+      this.length = 1;
    }
-    
    insert(value) {
-      let newNode = new Node(value);
-
-      let traverse = node => {
+      let currentNode = new Node(value);
+      this.length++;
+      let searchTree = node => {
          if(value < node.value) {
             if(!node.left) {
-               node.left = newNode;
+               node.left = currentNode;
             } else {
-               traverse(node.left);
+               searchTree(node.left)
             }
          } else if(value > node.value) {
             if(!node.right) {
-               node.right = newNode;
+               node.right = currentNode;
             } else {
-               traverse(node.right);
+               searchTree(node.right)
             }
          }
       }
+      searchTree(this.root);
+   }
 
-      traverse(this.root);
+   size() {
+      return this.length;
    }
 
    min() {
@@ -79,19 +80,15 @@ class BinarySearchTree {
    lookup(value) {
       let currentNode = this.root;
       while(currentNode) {
-         if(value === currentNode.value) {
+         if(currentNode.value == value) {
             return true;
          } else if(value < currentNode.value) {
             currentNode = currentNode.left;
          } else {
-            currentNode = currentNode.right;
+            currentNode = currentNode.right
          }
       }
-      return false;
-   }
-
-   size() {
-      return this.length;
+      return false
    }
 
    dfsInorder() {
@@ -107,9 +104,9 @@ class BinarySearchTree {
       // 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.left) searchTree(node.left)
+         result.push(node.value)
+         if(node.right) searchTree(node.right)
       }
       searchTree(this.root);
       return result;
@@ -125,9 +122,9 @@ class BinarySearchTree {
       // Output = 10,5,1,6,19,17,21
       let result = [];
       let searchTree = node => {
-         result.push(node.value);
-         if(node.left) searchTree(node.left);
-         if(node.right) searchTree(node.right);
+         result.push(node.value)
+         if(node.right) searchTree(node.right)
+         if(node.left) searchTree(node.left)
       }
       searchTree(this.root);
       return result;
@@ -143,9 +140,9 @@ class BinarySearchTree {
       // Output = 1,6,5,17,21,19,10
       let result = [];
       let searchTree = node => {
-         if(node.left) searchTree(node.left);
-         if(node.right) searchTree(node.right);
-         result.push(node.value);
+         if(node.right) searchTree(node.right)
+         if(node.left) searchTree(node.left)
+         result.push(node.value)
       }
       searchTree(this.root);
       return result;
@@ -158,19 +155,16 @@ class BinarySearchTree {
       //   1    6 17  21
 
       // Output - 10,5,19,1,6,17,21
-      let result = [];
       let queue = [];
+      let result = [];
       queue.push(this.root);
       while(queue.length) {
          let currentNode = queue.shift();
          result.push(currentNode.value);
-
          if(currentNode.left) {
-            queue.push(currentNode.left);
-         }
-
-         if(currentNode.right) {
-            queue.push(currentNode.right);
+            queue.push(currentNode.left)
+         } if(currentNode.right) {
+            queue.push(currentNode.right)
          }
       }
       return result;
@@ -239,6 +233,7 @@ function getLeafCountOfBinaryTree(node) {
    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) {
@@ -247,7 +242,7 @@ function hightOfBinaryTree(node) {
    } else {
       let lTree = hightOfBinaryTree(node.left);
       let rTree = hightOfBinaryTree(node.right);
-      if(lTree > rTree) {
+      if(lTree < rTree) {
          return lTree + 1;
       } else {
          return rTree + 1;

Datastructure/BinaryTree/practice.js

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

Datastructure/Graphs/practice.js

@@ -35,8 +35,8 @@
 class Node {
    constructor(value) {
       this.value = value;
-      this.next = null;
       this.prev = null;
+      this.next = null;
    }
 }
 class SinglyLinkedList {
@@ -45,44 +45,33 @@ class SinglyLinkedList {
       this.tail = this.head;
       this.length = 1;
    }
-   append(value) {
-      let newNode = new Node(value);
-      newNode.next = this.head;
-      this.head.prev = newNode; // Doubly LinkedList
-      this.head = newNode;
-      this.length++;
-      return this;
-   }
    prepand(value) {
       let newNode = new Node(value);
       this.tail.next = newNode;
-      newNode.prev = this.tail; // Doubly LinkedList
+      newNode.prev = this.tail.prev; //here
       this.tail = newNode;
       this.length++;
       return this;
    }
-   insert(value, index) {
-      if(index >= this.length) {
-         return this.append(value);
-      }
+   append(value) {
       let newNode = new Node(value);
-      let leaderNode = this.traverse(index - 1);
-      let nextNode = leaderNode.next;
-      leaderNode.next = newNode;
-      newNode.prev = leaderNode; // Doubly LinkedList
-      newNode.next = nextNode;
-      nextNode.prev = newNode; // Doubly LinkedList
+      newNode.next = this.head;
+      this.head.prev = newNode; // here
+      this.head = newNode;
       this.length++;
-      return this.printList();
+      return this;
    }
-   remove(index) {
-      if(index > this.length) {
-         return "Invalid Input !!!"
+   insert(index, value) {
+      if(index >= this.length) {
+         return this.prepand(index);
       }
+      let newNode = new Node(value);
       let leaderNode = this.traverse(index - 1);
       let unwantedNode = leaderNode.next;
-      leaderNode.next = unwantedNode.next;
-      this.length--;
+      leaderNode.next = newNode;
+      newNode.prev = leaderNode; // here
+      newNode.next = unwantedNode;
+      unwantedNode.prev = newNode; //here
       return this.printList();
    }
    reverse() {
@@ -97,21 +86,29 @@ class SinglyLinkedList {
       }
       this.head.next = null;
       this.head = first;
+   }
+   remove(index) {
+      if(index > this.length) {
+         return "Invaild Input !!!"
+      }
+      let leader = this.traverse(index - 1);
+      let unwantedNode = leader.next;
+      leader.next = unwantedNode.next;
       return this.printList();
    }
    traverse(index) {
-      let count = 0;
+      let counter = 0;
       let currentNode = this.head;
-      while(index != count) {
-         count++;
+      while(index != counter) {
+         counter++;
          currentNode = currentNode.next;
       }
       return currentNode;
    }
    printList() {
-      let result = [];
       let currentNode = this.head;
-      while(currentNode != null) {
+      let result = [];
+      while(currentNode !== null) {
          result.push(currentNode.value);
          currentNode = currentNode.next;
       }