Re-practice the basic algos

Author: metanet

src/problems/leetcode/InsertionSort.java

@@ -7,7 +7,7 @@ public class InsertionSort {
     // runtime: O(N^2)
     // space: O(1)
     public static void sort(int[] nums) {
-        if (nums == null || nums.length < 1) {
+        if (nums == null || nums.length < 2) {
             return;
         }
 

src/problems/leetcode/MaxHeap.java

@@ -0,0 +1,108 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+
+public class MaxHeap<T extends Comparable<T>> {
+
+    private T[] heap;
+    private int size;
+    private int maxSize;
+
+    // Constructor to initialize an
+    // empty max heap with given maximum
+    // capacity
+    public MaxHeap(int maxSize) {
+        // This keyword refers to current instance itself
+        this.maxSize = maxSize;
+        this.size = 0;
+        this.heap = (T[]) new Comparable[this.maxSize];
+    }
+
+    private int parent(int pos) {
+        return (pos - 1) / 2;
+    }
+
+    private int leftChild(int pos) {
+        return (2 * pos) + 1;
+    }
+
+    private int rightChild(int pos) {
+        return (2 * pos) + 2;
+    }
+
+    private void swap(int l, int r) {
+        T tmp;
+        tmp = heap[l];
+        heap[l] = heap[r];
+        heap[r] = tmp;
+    }
+
+    private void maxHeapify(int i) {
+        int l = leftChild(i);
+        int r = rightChild(i);
+        int largest = i;
+        if (l < size && heap[l].compareTo(heap[i]) > 0) {
+            largest = l;
+        }
+        if (r < size && heap[r].compareTo(heap[largest]) > 0) {
+            largest = r;
+        }
+        if (largest != i) {
+            swap(i, largest);
+            maxHeapify(largest);
+        }
+    }
+
+    public void add(T element) {
+        if (size == maxSize) {
+            throw new IllegalStateException("heap full!");
+        }
+
+        heap[size] = element;
+        int current = size;
+        while (heap[current].compareTo(heap[parent(current)]) > 0) {
+            swap(current, parent(current));
+            current = parent(current);
+        }
+        size++;
+    }
+
+    public T remove() {
+        if (size == 0) {
+            throw new IllegalStateException("empty heap!");
+        }
+        T popped = heap[0];
+        heap[0] = heap[--size];
+        heap[size] = null;
+        maxHeapify(0);
+        return popped;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(heap);
+    }
+
+    public static void main(String[] args) {
+        MaxHeap<Integer> heap = new MaxHeap<>(10);
+
+        heap.add(5);
+        heap.add(10);
+        heap.add(20);
+        heap.add(15);
+
+        System.out.println(heap);
+
+        System.out.println(heap.remove());
+        System.out.println(heap);
+
+        System.out.println(heap.remove());
+        System.out.println(heap);
+
+        System.out.println(heap.remove());
+        System.out.println(heap);
+
+        System.out.println(heap.remove());
+        System.out.println(heap);
+    }
+}

src/problems/leetcode/MergeSort.java

@@ -42,7 +42,7 @@ private static void sort(int[] nums, int lo, int hi, int[] aux) {
     // runtime: O(NlgN)
     // space: O(N)
     public static void sort(int[] nums) {
-        if (nums == null || nums.length < 1) {
+        if (nums == null || nums.length < 2) {
             return;
         }
 

src/problems/leetcode/QuickSort.java

@@ -0,0 +1,84 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+public class QuickSort {
+
+    // 5, 1, 4, 8, 0, 9
+    // pivot = 5
+    // 1, 4, 0, 5, 8, 9
+
+    private static void exch(int[] nums, int i, int j) {
+        if (i == j) {
+            return;
+        }
+
+        int n = nums[i];
+        nums[i] = nums[j];
+        nums[j] = n;
+    }
+
+    private static int partition(int[] nums, int lo, int hi) {
+        // Partition into nums[lo..i-1], a[i], nums[i+1..hi].
+        // where a[i] will be at its final place.
+        int i = lo, j = hi + 1; // left and right scan indices
+        int pivot = nums[i];
+        while (true) {
+            // Scan right, scan left, check for scan complete, and exchange.
+            while (nums[++i] < pivot) {
+                if (i == hi) {
+                    break;
+                }
+            }
+
+            while (pivot < nums[--j]) {
+                if (j == lo) {
+                    break;
+                }
+            }
+
+            if (i >= j) {
+                break;
+            }
+
+            exch(nums, i, j);
+        }
+
+        exch(nums, lo, j); // put pivot = nums[j] into its final position
+        return j; // with nums[lo..j-1] <= nums[j] <= nums[j+1..hi].
+    }
+
+    private static void sort(int[] nums, int lo, int hi) {
+        if (hi <= lo) {
+            return;
+        }
+
+        int p = partition(nums, lo, hi);
+        sort(nums, lo, p - 1);
+        sort(nums, p + 1, hi);
+    }
+
+    // space: O(1)
+    // runtime:
+    // - O(NlgN) on avg,
+    // - O(N^2) worst case, if the input is reverse sorted for e.g.
+    // we can avoid worst-case by shuffling before sort.
+    public static void sort(int[] nums) {
+        if (nums == null || nums.length < 2) {
+            return;
+        }
+
+        // shuffle the array to avoid the worst-case perf
+        Collections.shuffle(Arrays.asList(nums));
+        sort(nums, 0, nums.length - 1);
+        System.out.println(Arrays.toString(nums));
+    }
+
+    public static void main(String[] args) {
+        sort(new int[] { 1, 2, 3, 4, 5 });
+        sort(new int[] { 5, 4, 3, 2, 1 });
+        sort(new int[] { 1, 2, 3, 4, 5, 4, 3, 2, 1 });
+    }
+
+}

src/problems/leetcode/SelectionSort.java

@@ -7,7 +7,7 @@ public class SelectionSort {
     // space complexity: O(1)
     // runtime complexity: O(N^2)
     public static void sort(int[] nums) {
-        if (nums == null || nums.length < 1) {
+        if (nums == null || nums.length < 2) {
             return;
         }