diff --git a/Exercise_1.java b/Exercise_1.java
index c3ff1141..48ae7ea6 100644
--- a/Exercise_1.java
+++ b/Exercise_1.java
@@ -1,8 +1,25 @@
-class BinarySearch { 
+/*
+Space Complexity O(1) no extra space used
+Time Complexity  O(log(n)) where n is the no of elements in the array
+ */
+class BinarySearch {
     // Returns index of x if it is present in arr[l.. r], else return -1 
     int binarySearch(int arr[], int l, int r, int x) 
     { 
         //Write your code here
+        int mid=0;
+        while(l<=r) {
+            mid=l+(r-l)/2;
+            if(arr[mid]==x)
+                return mid;
+            if(x<arr[mid]){
+                r=mid-1;
+            }
+            else {
+                l=mid+1;
+            }
+        }
+        return -1;
     } 
   
     // Driver method to test above 
diff --git a/Exercise_2.java b/Exercise_2.java
index d0b5fa5f..7c434eda 100644
--- a/Exercise_2.java
+++ b/Exercise_2.java
@@ -1,48 +1,73 @@
-class QuickSort 
-{ 
-    /* This function takes last element as pivot, 
-       places the pivot element at its correct 
-       position in sorted array, and places all 
-       smaller (smaller than pivot) to left of 
-       pivot and all greater elements to right 
+/*
+Space Complexity O(n) - recursive stack call
+Time Complexity average nlog(n)
+                worst n^2
+*/
+class QuickSort
+{
+    /* This function takes last element as pivot,
+       places the pivot element at its correct
+       position in sorted array, and places all
+       smaller (smaller than pivot) to left of
+       pivot and all greater elements to right
        of pivot */
     void swap(int arr[],int i,int j){
-        //Your code here   
+        //Your code here
+        int temp=arr[i];
+        arr[i]=arr[j];
+        arr[j]=temp;
     }
-    
-    int partition(int arr[], int low, int high) 
-    { 
-   	//Write code here for Partition and Swap 
-    } 
-    /* The main function that implements QuickSort() 
-      arr[] --> Array to be sorted, 
-      low  --> Starting index, 
+
+    int partition(int arr[], int low, int high)
+    {
+   	//Write code here for Partition and Swap
+        int pivot=arr[high];
+
+        int i=low-1;
+        for(int j=low;j<=high-1;j++){
+            if(arr[j]<pivot){
+                i++;
+                swap(arr,i,j);
+            }
+        }
+
+        swap(arr,i+1,high);
+        return i+1;
+    }
+    /* The main function that implements QuickSort()
+      arr[] --> Array to be sorted,
+      low  --> Starting index,
       high  --> Ending index */
-    void sort(int arr[], int low, int high) 
-    {  
-            // Recursively sort elements before 
-            // partition and after partition 
-    } 
-  
+    void sort(int arr[], int low, int high)
+    {
+            // Recursively sort elements before
+            // partition and after partition
+        if(low < high) {
+            int partition = partition(arr,low,high);
+            sort(arr,low,partition-1);
+            sort(arr,partition+1,high);
+        }
+    }
+
     /* A utility function to print array of size n */
-    static void printArray(int arr[]) 
-    { 
-        int n = arr.length; 
-        for (int i=0; i<n; ++i) 
-            System.out.print(arr[i]+" "); 
-        System.out.println(); 
-    } 
-  
-    // Driver program 
-    public static void main(String args[]) 
-    { 
-        int arr[] = {10, 7, 8, 9, 1, 5}; 
-        int n = arr.length; 
-  
-        QuickSort ob = new QuickSort(); 
-        ob.sort(arr, 0, n-1); 
-  
-        System.out.println("sorted array"); 
-        printArray(arr); 
-    } 
-} 
+    static void printArray(int arr[])
+    {
+        int n = arr.length;
+        for (int i=0; i<n; ++i)
+            System.out.print(arr[i]+" ");
+        System.out.println();
+    }
+
+    // Driver program
+    public static void main(String args[])
+    {
+        int arr[] = {10, 7, 8, 9, 1, 5};
+        int n = arr.length;
+
+        QuickSort ob = new QuickSort();
+        ob.sort(arr, 0, n-1);
+
+        System.out.println("sorted array");
+        printArray(arr);
+    }
+}
diff --git a/Exercise_3.java b/Exercise_3.java
index 1f9b752a..a72432ee 100644
--- a/Exercise_3.java
+++ b/Exercise_3.java
@@ -1,53 +1,64 @@
-class LinkedList 
-{ 
-    Node head; // head of linked list 
-  
+/*
+Time Complexity O(n) n is no of nodes in the linked list
+Space Complexity O(1)
+ */
+class LinkedList
+{
+    Node head; // head of linked list
+
     /* Linked list node */
-    class Node 
-    { 
-        int data; 
-        Node next; 
-        Node(int d) 
-        { 
-            data = d; 
-            next = null; 
-        } 
-    } 
-  
+    class Node
+    {
+        int data;
+        Node next;
+        Node(int d)
+        {
+            data = d;
+            next = null;
+        }
+    }
+
     /* Function to print middle of linked list */
    //Complete this function
-    void printMiddle() 
-    { 
+    void printMiddle()
+    {
         //Write your code here
 	//Implement using Fast and slow pointers
-    } 
-  
-    public void push(int new_data) 
-    { 
-        Node new_node = new Node(new_data); 
-        new_node.next = head; 
-        head = new_node; 
-    } 
+        Node slow=head;
+        Node fast=head;
+        while(fast!=null && fast.next!=null){
+            slow=slow.next;
+            fast=fast.next.next;
+        }
+        System.out.println(slow.data);
+    }
+
+    public void push(int new_data)
+    {
+        Node new_node = new Node(new_data);
+        new_node.next = head;
+        head = new_node;
+    }
+
+    public void printList()
+    {
+        Node tnode = head;
+        while (tnode != null)
+        {
+            System.out.print(tnode.data+"->");
+            tnode = tnode.next;
+        }
+        System.out.println("NULL");
+    }
 
-    public void printList() 
-    { 
-        Node tnode = head; 
-        while (tnode != null) 
-        { 
-            System.out.print(tnode.data+"->"); 
-            tnode = tnode.next; 
-        } 
-        System.out.println("NULL"); 
-    } 
-  
-    public static void main(String [] args) 
-    { 
-        LinkedList llist = new LinkedList(); 
-        for (int i=15; i>0; --i) 
-        { 
-            llist.push(i); 
-            llist.printList(); 
-            llist.printMiddle(); 
-        } 
-    } 
-} 
\ No newline at end of file
+    public static void main(String [] args)
+    {
+        LinkedList llist = new LinkedList();
+        for (int i=15; i>0; --i)
+        {
+            llist.push(i);
+            llist.printList();
+            llist.printMiddle();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Exercise_4.java b/Exercise_4.java
index 81afd3c2..958435a9 100644
--- a/Exercise_4.java
+++ b/Exercise_4.java
@@ -1,42 +1,84 @@
-class MergeSort 
-{ 
-    // Merges two subarrays of arr[]. 
-    // First subarray is arr[l..m] 
-    // Second subarray is arr[m+1..r] 
-    void merge(int arr[], int l, int m, int r) 
-    {  
-       //Your code here  
-    } 
-  
-    // Main function that sorts arr[l..r] using 
-    // merge() 
-    void sort(int arr[], int l, int r) 
-    { 
+
+/*
+Time Complexity  n(log(n))
+Space Complexity O(n) temporary array
+*/
+class MergeSort
+{
+    // Merges two subarrays of arr[].
+    // First subarray is arr[l..m]
+    // Second subarray is arr[m+1..r]
+    void merge(int arr[], int l, int m, int r)
+    {
+       //Your code here
+        int len1=m-l+1;
+        int len2=r-m;
+
+        int[] left=new int[len1];
+        int[] right=new int[len2];
+
+        for(int i=0;i<len1;i++)
+            left[i]=arr[l+i];
+        for(int i=0;i<len2;i++)
+            right[i]=arr[m+1+i];
+
+        int i=0,j=0;
+        int k=l;
+        while(i<len1 && j<len2){
+            if(left[i]<=right[j]){
+                arr[k++]=left[i++];
+            }
+            else{
+                arr[k++]=right[j++];
+            }
+        }
+
+        while(i<len1){
+            arr[k++]=left[i++];
+        }
+
+        while(j<len2){
+            arr[k++]=right[j++];
+        }
+    }
+
+    // Main function that sorts arr[l..r] using
+    // merge()
+    void sort(int arr[], int l, int r)
+    {
 	//Write your code here
-        //Call mergeSort from here 
-    } 
-  
+        if(l<r){
+            int mid=l+(r-l)/2;
+
+            sort(arr,l,mid);
+            sort(arr,mid+1,r);
+
+            //Call mergeSort from here
+            merge(arr,l,mid,r);
+        }
+    }
+
     /* A utility function to print array of size n */
-    static void printArray(int arr[]) 
-    { 
-        int n = arr.length; 
-        for (int i=0; i<n; ++i) 
-            System.out.print(arr[i] + " "); 
-        System.out.println(); 
-    } 
-  
-    // Driver method 
-    public static void main(String args[]) 
-    { 
-        int arr[] = {12, 11, 13, 5, 6, 7}; 
-  
-        System.out.println("Given Array"); 
-        printArray(arr); 
-  
-        MergeSort ob = new MergeSort(); 
-        ob.sort(arr, 0, arr.length-1); 
-  
-        System.out.println("\nSorted array"); 
-        printArray(arr); 
-    } 
-} 
\ No newline at end of file
+    static void printArray(int arr[])
+    {
+        int n = arr.length;
+        for (int i=0; i<n; ++i)
+            System.out.print(arr[i] + " ");
+        System.out.println();
+    }
+
+    // Driver method
+    public static void main(String args[])
+    {
+        int arr[] = {12, 11, 13, 5, 6, 7};
+
+        System.out.println("Given Array");
+        printArray(arr);
+
+        MergeSort ob = new MergeSort();
+        ob.sort(arr, 0, arr.length-1);
+
+        System.out.println("\nSorted array");
+        printArray(arr);
+    }
+}
\ No newline at end of file
diff --git a/Exercise_5.java b/Exercise_5.java
index 30e82675..f57bc316 100644
--- a/Exercise_5.java
+++ b/Exercise_5.java
@@ -1,36 +1,76 @@
-class IterativeQuickSort { 
-    void swap(int arr[], int i, int j) 
-    { 
-	//Try swapping without extra variable 
-    } 
-  
-    /* This function is same in both iterative and 
+
+/*
+Space Complexity O(n) - recursive stack call
+Time Complexity average nlog(n)
+*/
+class IterativeQuickSort {
+    void swap(int arr[], int i, int j)
+    {
+	//Try swapping without extra variable
+        if(i!=j){
+            arr[i]=arr[i]+arr[j];
+            arr[j]=arr[i]-arr[j];
+            arr[i]=arr[i]-arr[j];
+        }
+    }
+
+    /* This function is same in both iterative and
        recursive*/
-    int partition(int arr[], int l, int h) 
-    { 
+    int partition(int arr[], int l, int h)
+    {
         //Compare elements and swap.
-    } 
-  
-    // Sorts arr[l..h] using iterative QuickSort 
-    void QuickSort(int arr[], int l, int h) 
-    { 
+        int pivot=arr[h];
+        int i=l-1;
+        for(int j=l;j<=h-1;j++){
+            if(arr[j]<=pivot){
+                i++;
+                swap(arr,i,j);
+            }
+        }
+        swap(arr,i+1,h);
+        return i+1;
+    }
+
+    // Sorts arr[l..h] using iterative QuickSort
+    void QuickSort(int arr[], int l, int h)
+    {
         //Try using Stack Data Structure to remove recursion.
-    } 
-  
-    // A utility function to print contents of arr 
-    void printArr(int arr[], int n) 
-    { 
-        int i; 
-        for (i = 0; i < n; ++i) 
-            System.out.print(arr[i] + " "); 
-    } 
-  
-    // Driver code to test above 
-    public static void main(String args[]) 
-    { 
-        IterativeQuickSort ob = new IterativeQuickSort(); 
-        int arr[] = { 4, 3, 5, 2, 1, 3, 2, 3 }; 
-        ob.QuickSort(arr, 0, arr.length - 1); 
-        ob.printArr(arr, arr.length); 
-    } 
-} 
\ No newline at end of file
+        int[] aux=new int[h-l+1];
+        int top=-1;
+        aux[++top]=l;
+        aux[++top]=h;
+
+        while(top>=0){
+            h=aux[top--];
+            l=aux[top--];
+            int partition=partition(arr,l,h);
+
+            if(l<partition-1){
+                aux[++top]=l;
+                aux[++top]=partition-1;
+            }
+
+            if(partition+1<h){
+                aux[++top]=partition+1;
+                aux[++top]=h;
+            }
+        }
+    }
+
+    // A utility function to print contents of arr
+    void printArr(int arr[], int n)
+    {
+        int i;
+        for (i = 0; i < n; ++i)
+            System.out.print(arr[i] + " ");
+    }
+
+    // Driver code to test above
+    public static void main(String args[])
+    {
+        IterativeQuickSort ob = new IterativeQuickSort();
+        int arr[] = { 4, 3, 5, 2, 1, 3, 2, 3 };
+        ob.QuickSort(arr, 0, arr.length - 1);
+        ob.printArr(arr, arr.length);
+    }
+}
\ No newline at end of file