Re-practice the basic algos

Author: metanet

src/problems/leetcode/ArithmeticEval.java

@@ -0,0 +1,42 @@
+package problems.leetcode;
+
+public class ArithmeticEval {
+
+    // Given a string of an arithmetic expression, composed of numbers, 
+    // '+' and '*', calculate the result -
+    //
+    // 2 + 4 * 5 * 7
+    //
+    // 1 + 2 + 5
+    //
+    // 2 + 4 * 5 + 7
+
+    static int eval(String exp) {
+        int result = 0, current = 1;
+        for (String token : exp.split(" ")) {
+            if (token.isBlank()) {
+                continue;
+            } else if (token.equals("+")) {
+                result += current;
+                current = 1;
+            } else if (!token.equals("*")) {
+                current *= Integer.parseInt(token);
+            }
+        }
+
+        return result + current;
+    }
+
+    public static void main(String[] args) {
+        String exp1 = "2 + 4 * 5 + 7";
+        String exp2 = "1 + 2 + 3";
+        String exp3 = "1 + 2";
+        String exp4 = "2 * 4";
+        String exp5 = "24";
+        System.out.println(eval(exp1));
+        System.out.println(eval(exp2));
+        System.out.println(eval(exp3));
+        System.out.println(eval(exp4));
+        System.out.println(eval(exp5));
+    }
+}

src/problems/leetcode/BinarySearch.java

@@ -0,0 +1,30 @@
+package problems.leetcode;
+
+public class BinarySearch {
+
+    private static int binarySearch(int[] vals, int val) {
+        int l = 0, h = vals.length - 1;
+
+        while (l <= h) {
+            int m = (l + h) / 2;
+            if (vals[m] == val) {
+                return m;
+            } else if (vals[m] < val) {
+                l = m + 1;
+            } else {
+                h = m - 1;
+            }
+        }
+
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(binarySearch(new int[] { 1, 2, 3, 4, 5 }, 3));
+        System.out.println(binarySearch(new int[] { 1, 2, 3, 4, 5 }, 5));
+        System.out.println(binarySearch(new int[] { 1, 2, 3, 4, 5 }, 1));
+        System.out.println(binarySearch(new int[] { 1, 2, 3, 4, 5 }, 6));
+        System.out.println(binarySearch(new int[] { 1, 2, 3, 4, 5 }, -5));
+    }
+
+}

src/problems/leetcode/InsertionSort.java

@@ -0,0 +1,31 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+
+public class InsertionSort {
+
+    // runtime: O(N^2)
+    // space: O(1)
+    public static void sort(int[] nums) {
+        if (nums == null || nums.length < 1) {
+            return;
+        }
+
+        for (int i = 1; i < nums.length; i++) {
+            for (int j = i; j > 0 && nums[j] < nums[j - 1]; j--) {
+                int num = nums[j];
+                nums[j] = nums[j - 1];
+                nums[j - 1] = num;
+            }
+        }
+
+        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/MergeSort.java

@@ -0,0 +1,59 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+
+public class MergeSort {
+
+    private static void merge(int[] nums, int lo, int mid, int hi, int[] aux) {
+        // Merge nums[lo..mid] with nums[mid+1..hi].
+        int i = lo, j = mid + 1;
+        // Copy nums[lo..hi] to nums[lo..hi].
+        for (int k = lo; k <= hi; k++) {
+            aux[k] = nums[k];
+        }
+
+        // Merge back to a[lo..hi].
+        for (int k = lo; k <= hi; k++) {
+            if (i > mid) {
+                nums[k] = aux[j++];
+            } else if (j > hi) {
+                nums[k] = aux[i++];
+            } else if (aux[j] < aux[i]) {
+                nums[k] = aux[j++];
+            } else {
+                nums[k] = aux[i++];
+            }
+        }
+    }
+
+    private static void sort(int[] nums, int lo, int hi, int[] aux) {
+        // sort nums[lo..hi]
+
+        if (hi <= lo) {
+            return;
+        }
+
+        int mid = (lo + hi) / 2;
+        sort(nums, lo, mid, aux);
+        sort(nums, mid + 1, hi, aux);
+        merge(nums, lo, mid, hi, aux);
+    }
+
+    // runtime: O(NlgN)
+    // space: O(N)
+    public static void sort(int[] nums) {
+        if (nums == null || nums.length < 1) {
+            return;
+        }
+
+        sort(nums, 0, nums.length - 1, new int[nums.length]);
+        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/ReverseLinkedList.java

@@ -12,9 +12,25 @@ private static class ListNode {
         ListNode(int x) {
             val = x;
         }
+
+        @Override
+        public String toString() {
+            return next != null ? (val + " -> " + next.toString()) : String.valueOf(val);
+        }
     }
 
-    public ListNode reverseList(ListNode head) {
+    // 1 - > 2  -> 3 -> 4
+
+    // head = 1
+    // curr = head
+    // prev = null
+    
+    // next = curr.next 
+    // curr.next = prev
+    // prev = curr
+    // curr = next
+
+    public static ListNode reverseList(ListNode head) {
         ListNode prev = null;
         ListNode current = head;
         while (current != null) {
@@ -26,4 +42,13 @@ public ListNode reverseList(ListNode head) {
 
         return prev;
     }
+
+    public static void main(String[] args) {
+        ListNode head = new ListNode(1);
+        head.next = new ListNode(2);
+        head.next.next = new ListNode(3);
+        System.out.println(head);
+        head = reverseList(head);
+        System.out.println(head);
+    }
 }

src/problems/leetcode/SelectionSort.java

@@ -0,0 +1,35 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+
+public class SelectionSort {
+
+    // space complexity: O(1)
+    // runtime complexity: O(N^2)
+    public static void sort(int[] nums) {
+        if (nums == null || nums.length < 1) {
+            return;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            int k = i;
+            for (int j = i; j < nums.length; j++) {
+                if (nums[k] > nums[j]) {
+                    k = j;
+                }
+            }
+            int num = nums[i];
+            nums[i] = nums[k];
+            nums[k] = num;
+        }
+
+        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/TwoStackEval.java

@@ -0,0 +1,73 @@
+package problems.leetcode;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Stack;
+
+public class TwoStackEval {
+    
+    
+    private static void eval(Stack<String> ops, Stack<Double> vals) {
+        if (vals.size() < 2 || ops.isEmpty()) {
+            throw new IllegalArgumentException("invalid expression");
+        }
+
+        double val2 = vals.pop();
+        double val1 = vals.pop();
+        String op = ops.pop();
+
+        double result;
+        if (op.equals("+")) {
+            result = val1 + val2;
+        } else if (op.equals("-")) {
+            result = val1 - val2;
+        } else if (op.equals("*")) {
+            result = val1 * val2;
+        } else if (op.equals("/")) { 
+            result = val1 / val2;
+        } else {
+            throw new IllegalArgumentException("invalid op: " + op);
+        }
+        vals.push(result);
+    }
+
+    public static double eval(String str) {
+    
+        Stack<String> ops = new Stack<>();
+        Stack<Double> vals = new Stack<>();
+
+        for (String token : str.split(" ")) {
+            if (token.isBlank()) {
+                continue;
+            }
+
+            if (token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/")) {
+                ops.push(token);
+            } else if (token.equals("(")) {
+                // ignore (
+                continue;
+            } else if (token.equals(")")) {
+                eval(ops, vals);
+            } else {
+                vals.push(Double.parseDouble(token));
+            }
+        }
+
+        while (vals.size() > 1) {
+            eval(ops, vals);
+        }
+
+        return !vals.empty() ? vals.pop() : 0;
+    }
+
+    public static void main(String[] args) {
+        String exp1 = "1 + 2 + 3";
+        String exp2 = "4 + ( 2 - 3 )";
+        String exp3 = "( 1 + ( ( 2 + 3 ) * ( 4 * 5 ) ) )";
+        System.out.println(eval(exp1));
+        System.out.println(eval(exp2));
+        System.out.println(eval(exp3));
+    }
+
+
+}