minor corrections

Author: Ram swaroop

src/me/ramswaroop/arrays/sorting/QuickSort.java

@@ -28,9 +28,10 @@ public static int partition(int[] ar, int low, int high) {
         for (int i = low; i < high; i++) {
             /**
              * if ith element is smaller than pivot element then
-             * swap it with the last larger element known.
+             * swap it with the last larger element known
              */
             if (ar[i] < ar[pivot]) {
+                // swap a[low] with a[i]
                 temp = ar[low];
                 ar[low] = ar[i];
                 ar[i] = temp;
@@ -48,7 +49,8 @@ public static int partition(int[] ar, int low, int high) {
 
     /**
      * Recursive Quick sort.
-     * NOTE: This function is tail-recursive.
+     * NOTE: This function is tail-recursive (doesn't use 
+     * extra stack space per recursive call).
      * <p/>
      * Time complexity:
      * Best Case:   O(nlogn)

src/me/ramswaroop/arrays/sorting/SelectionSort.java

@@ -19,7 +19,7 @@ public class SelectionSort {
      * element is chosen and placed at the appropriate position and then again the
      * logic is applied on rest of the elements till the entire array is sorted.
      * <p/>
-     * Time complexity: O(n) for all cases.
+     * Time complexity: O(n*n) for all cases.
      * <p/>
      * NOTE: Advantage of this sort is that it requires minimum number of memory writes
      * like Cycle sort.

src/me/ramswaroop/common/MaxHeap.java

@@ -73,10 +73,22 @@ public void buildMaxHeap() {
         }
     }
 
+    /**
+     * Insert a new element into the heap satisfying
+     * the heap property.
+     * 
+     * Time complexity: O(log n) where 'n' is total no. of 
+     * elements in heap or O(h) where 'h' is the height of
+     * heap.
+     * 
+     * @param elem
+     */
     public void insert(int elem) {
+        // increase heap size
         heap = Arrays.copyOf(heap, size + 1);
         int i = size;
         int parentIndex = (int) Math.floor((i - 1) / 2);
+        // move up through the heap till you find the right position
         while (i > 0 && elem > heap[parentIndex]) {
             heap[i] = heap[parentIndex];
             i = parentIndex;