Updated

Author: jeyrschabu

min_heap.md

@@ -2,8 +2,8 @@ Min Heap Algorithm
 ========================
 
 Implementations:
-[MINHEAP]
-```
+
+```java
 class MinHeap {
     int[] heap;
     int maxSize;
@@ -14,18 +14,23 @@ class MinHeap {
         heap = new heap[maxSize + 1];
         heap[0] = Integer.MIN_VALUE;
     }
+
     int parent(int position) { 
         return position / 2; 
     }
+
     int left(int position) { 
         return position * 2; 
     }
+
     int right(int position) { 
         return position * 2 + 1;
     }
+
     boolean isLeaf(int position) {
         return (position >= counter/2 && position <= counter)
     }
+
     void insert(int element) {
         heap[++counter] = element;
         int i = counter;
@@ -34,12 +39,14 @@ class MinHeap {
             current = parent(current);
         }
     }
+
     int remove() {
         int popped = heap[FRONT];
         heap[FRONT] = heap[counter--];
         minify(FRONT);
         return popped;
     }
+
     void minify(int position) {
         if (!isLeaf(pos)) {
             if (heap[pos]) > heap[left(pos)] || heap[pos] < heap[right(pos)]) { 
@@ -53,25 +60,28 @@ class MinHeap {
             }
         }
     }
+
     void extractMin() {
-        if (counter == 0) return Integer.MAX_VALUE;
+        if (counter == 0) {
+            return Integer.MAX_VALUE;
+        }
+
         int root = heap[0];
+
         if (counter > 1) {
             heap[0] = heap[counter - 1];
         }
+
         counter--;
     }
 }
-```
-[/MINHEAP]
 
-[KTH SMALLEST]
-```
 int kthSmallest(int a[], int n, int k) {
    //build the heap and use the insert method mh
-   for (int i=0; i < k-1; i++)
+   for (int i=0; i < k-1; i++) {
         mh.extractMin();
+   }
+
    return mh.getMin();
 }
 ```
-[/KTH SMALLEST]

quick_sort.md

@@ -3,29 +3,32 @@ QuickSort Algorithm
 
 Implementations:
 
-[QUICKSORT]
-
-```
+```java
 //O(n log n)
 void quickSort(int a[], int left, int right) {
       int index = partition(a, left, right);
-      if (left < index - 1)
+      if (left < index - 1) {
             quickSort(a, left, index - 1);
-      if (index < right)
+      }
+
+      if (index < right) {
             quickSort(a, index, right);
+      }
 }
-```
-[/QUICKSORT]
 
-[PARTITION]
-```
 int partition(int numbers[], int left, int right) {
     int i = left, j = right;
     int tmp;
     int pivot = numbers[(left + right) / 2];
     while (i <= j) {
-        while (numbers[i] < pivot) i++;
-        while (numbers[j] > pivot) j--;    
+        while (numbers[i] < pivot) {
+            i++;
+        }
+
+        while (numbers[j] > pivot) {
+            j--;
+        }
+
         if (i <= j) {
             tmp = numbers[i];
             arr[i] = numbers[j];
@@ -34,7 +37,7 @@ int partition(int numbers[], int left, int right) {
             j--;
         }
     }
+
     return i;
 }
-```
-[/PARTITION]
+```

selection_rank.md

@@ -19,16 +19,29 @@ int rank(int[] array, int left, int right, int rank) {
     int pivot = array[random];
     int leftEnd = partition(array, left, right, pivot); //partition
     int leftSize = leftEnd - left + 1;
-    if (leftSize == rank + 1) return Math.max(array[left], array[leftEnd]);
-    else if (rank < leftSide) return rank(array, left, leftEnd, rank);
-    else return rank(array, leftEnd + 1, right, rank - leftSize);
+    if (leftSize == rank + 1) {
+        return Math.max(array[left], array[leftEnd]);
+    } else if (rank < leftSide) {
+        return rank(array, left, leftEnd, rank);
+    } else {
+        return rank(array, leftEnd + 1, right, rank - leftSize);
+    }
 }
 
 int partition(int[] array, int left, int right, int pivot) {
     while (true) {
-        while (left <= right && array[left] <= pivot) left++;
-        while (left <= right && array[right] > pivot) right--;
-        if (left > right) return left -1;
+        while (left <= right && array[left] <= pivot) {
+            left++;
+        }
+
+        while (left <= right && array[right] > pivot) {
+            right--;
+        }
+
+        if (left > right) {
+            return left -1;
+        }
+        
         swap(array, left, right);
     }
 }

strings.md

@@ -5,10 +5,14 @@ Strings
 
 ```java
 boolean isRotation(String s1, String s2) {
-	if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) return false;
+	if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
+        return false;
+    }
+
 	if (s1.length() == s2.length()) {
 	    return isSubString(s1+s1, s2);
 	}
+    
 	return false;
 }
 ```