Updated 14 solutions

Author: RodneyShag

Chp. 01 - Arrays and Strings/_1_6_String_Compression/StringCompression.java

@@ -19,7 +19,7 @@ public static String basicCompression(String str) {
             }
         }
 
-        /* Accounts for last character */
+        // Accounts for last character
         sb.append(str.charAt(str.length() - 1));
         sb.append(String.valueOf(numSame));
 

Chp. 01 - Arrays and Strings/_1_8_Zero_Matrix/Tester.java

@@ -5,22 +5,23 @@
 public class Tester {
     public static void main(String[] args) {
         System.out.println("*** Test 1.8: Zero Matrix\n");
-        int[][] matrix = {{ 1, 2, 3 },
-                          { 0, 5, 6 }};
+        int[][] matrix1 = {{ 1, 2, 3, 1 },
+                           { 4, 5, 6, 0 },
+                           { 0, 5, 3, 0 }};
 
         int[][] matrix2 = {{ 1, 2, 3, 1 },
                            { 4, 5, 6, 0 },
                            { 0, 5, 3, 0 }};
 
-        testMatrix(matrix);
+        testMatrix(matrix1);
         testMatrix(matrix2);
     }
 
     private static void testMatrix(int[][] matrix) {
         System.out.println("Original matrix");
         Functions.printImage(matrix); // uses print function above in 1.6
         System.out.println("Zero out necessary rows/columns");
-        ZeroMatrix.zero(matrix);
+        ZeroMatrix.solution1(matrix);
         Functions.printImage(matrix);
         System.out.println();
     }

Chp. 01 - Arrays and Strings/_1_8_Zero_Matrix/ZeroMatrix.java

@@ -1,29 +1,110 @@
 package _1_8_Zero_Matrix;
 
+// Solutions                   Runtime    Space    
+// -----------------------------------------------
+// 1. Using 2 arrays           O(m * n)   O(m + n)
+// 2. Using input as storage   O(m * n)   O(1)             
+
 public class ZeroMatrix {
-    public static void zero(int[][] array) {
-        int M = array.length;
-        int N = array[0].length;
+    
+    // Algorithm
+    //
+    // 1. Create a boolean array to save which rows have 0s.
+    // 2. Repeat above step for columns.
+    // 3. Loop through 2-d grid to figure out which rows & columns have a 0.
+    // 4. Re-loop through 2-d grid and set whichever entries are necessary to 0.
+
+    public static void solution1(int[][] grid) {
+        int M = grid.length;
+        int N = grid[0].length;
 
-        /* Figure out which rows & columns should become 0 */
+        // Loop through 2-d grid to figure out which rows & columns have a 0
         boolean[] rows = new boolean[M];
         boolean[] cols = new boolean[N];
         for (int row = 0; row < M; row++) {
             for (int col = 0; col < N; col++) {
-                if (array[row][col] == 0) {
+                if (grid[row][col] == 0) {
                     rows[row] = true;
                     cols[col] = true;
                 }
             }
         }
 
-        /* Re-loop through 2-d matrix and set whichever entries are necessary to 0 */
+        // Re-loop through 2-d matrix and set whichever entries are necessary to 0
         for (int row = 0; row < M; row++) {
             for (int col = 0; col < N; col++) {
                 if (rows[row] == true || cols[col] == true) {
-                    array[row][col] = 0;
+                    grid[row][col] = 0;
+                }
+            }
+        }
+    }
+
+    // Algorithm
+    //
+    // - To achieve an O(1) space solution, instead of using 2 new boolean arrays as in above solution, we will
+    // use the array itself as storage. Specifically, we will use the 0th row and 0th column as our 2 arrays.
+    // - To be able to overwrite the values in the 0th row and 0th col, we will process them first.
+    //
+    // 1. Check if row 0 has a 0. Save this info for later.
+    // 2. Check if col 0 has a 0. Save this info for later.
+    // 3. Use row 0 and col 0 as storage. Loop through grid and save which rows and columns have 0s.
+    // 4. Zero out the necessary cells in grid (except for 0th row and 0th col).
+    // 5. Zero out the necessary cells in row 0.
+    // 6. Zero out the necessary cells in col 0.
+
+    public static void solution2(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        
+        // Check if row 0 has a 0. Save this info for later.
+        boolean row0Has0 = false;
+        for (int col = 0; col < cols; col++) {
+            if (grid[0][col] == 0) {
+                row0Has0 = true;
+            }
+        }
+
+        // Check if col 0 has a 0. Save this info for later.
+        boolean col0Has0 = false;
+        for (int row = 0; row < rows; row++) {
+            if (grid[row][0] == 0) {
+                col0Has0 = true;
+            }
+        }
+        
+        // Use row 0 and col 0 as storage.
+        // Loop through grid and save which rows and columns have 0s. 
+        for (int row = 0; row < rows; row++) {
+            for (int col = 0; col < cols; col++) {
+                if (grid[row][col] == 0) {
+                    grid[row][0] = 0;
+                    grid[0][col] = 0;
+                }
+            }
+        }
+        
+        // Zero out the necessary cells in grid (except for 0th row and 0th col).
+        for (int row = 1; row < rows; row++) {
+            for (int col = 1; col < cols; col++) {
+                if (grid[row][0] == 0 || grid[0][col] == 0) {
+                    grid[row][col] = 0;
                 }
             }
         }
+        
+        // Zero out the necessary cells in row 0.
+        if (row0Has0) {
+            for (int col = 0; col < cols; col++) {
+                grid[0][col] = 0;
+            }
+        }
+        
+        // Zero out the necessary cells in col 0.
+        if (col0Has0) {
+            for (int row = 0; row < rows; row++) {
+                grid[row][0] = 0;
+            }
+        }
     }
 }

Chp. 02 - Linked Lists/_2_5_Sum_Lists/Pair.java

@@ -1,92 +1,76 @@
 package _2_5_Sum_Lists;
 
 import common.Node;
-import common.ListFunctions;
+import java.util.Stack;
 
 public class SumLists {
-    /* Reverse Order: Iterative solution */
-    public static Node addReverseOrder(Node n, Node m) {
-        if (n == null) {
+    public static Node addReverseOrder(Node m, Node n) {
+        if (m == null) {
             return m;
-        } else if (m == null) {
+        } else if (n == null) {
             return n;
         }
         int carry = 0;
-        Node head = null;
-        Node tail = null;
-        while (n != null || m != null || carry != 0) {
+        Node dummy = new Node(0); // 1 Node before the actual head of list
+        Node tail = dummy;
+        while (m != null || n != null || carry != 0) {
             int value = carry;
-            if (n != null) {
-                value += n.data;
-                n = n.next;
-            }
             if (m != null) {
                 value += m.data;
                 m = m.next;
             }
+            if (n != null) {
+                value += n.data;
+                n = n.next;
+            }
             int digit = value % 10;
             carry = value / 10;
-            Node toAdd = new Node(digit);
-            if (head == null) {
-                head = toAdd;
-                tail = toAdd;
-            } else {
-                tail.next = toAdd;
-                tail = toAdd;
-            }
+            tail.next = new Node(digit);
+            tail = tail.next;
         }
-        return head;
+        return dummy.next;
     }
 
-    /* Forward Order: Recursive solution */
-    public static Node addForwardOrder(Node n, Node m) {
-        /* Pad the shorter list with 0's */
-        int sizeN = ListFunctions.calculateSize(n);
-        int sizeM = ListFunctions.calculateSize(m);
-        if (sizeN > sizeM) {
-            int numberOfZerosToInsert = sizeN - sizeM;
-            for (int i = 0; i < numberOfZerosToInsert; i++) {
-                m = ListFunctions.insertInFront(m, 0);
-            }
-        } else if (sizeM > sizeN) {
-            int numberOfZerosToInsert = sizeM - sizeN;
-            for (int i = 0; i < numberOfZerosToInsert; i++) {
-                n = ListFunctions.insertInFront(n, 0);
-            }
+    public static Node addForwardOrder(Node m, Node n) {
+        if (m == null) {
+            return m;
+        } else if (n == null) {
+            return n;
         }
 
-        /* Do the addition */
-        Pair result = addForwardOrderHelper(n, m);
+        Stack<Integer> stack1 = new Stack<>();
+        Stack<Integer> stack2 = new Stack<>();
 
-        /* Account for the carry if necessary */
-        if (result.carry == 0) {
-            return result.node;
-        } else {
-            Node head = new Node(result.carry);
-            head.next = result.node;
-            return head;
+        while (m != null) {
+            stack1.push(m.data);
+            m = m.next;
         }
-    }
-
-    private static Pair addForwardOrderHelper(Node n, Node m) {
-        // Either both "n" and "m" are null, or neither are null
-        if (n == null) {
-            return new Pair(null, 0);
+        while (n != null) {
+            stack2.push(n.data);
+            n = n.next;
         }
 
-        Pair rest = addForwardOrderHelper(n.next, m.next);
-        int value = n.data + m.data + rest.carry;
-
-        int digit = value % 10;
-        int carry = value / 10;
-
-        Node head = new Node(digit);
-        head.next = rest.node;
-        return new Pair(head, carry);
+        int carry = 0;
+        Node dummy = new Node(0); // 1 Node before the actual head of list
+        while (!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {
+            int value = carry;
+            if (!stack1.isEmpty()) {
+                value += stack1.pop();
+            }
+            if (!stack2.isEmpty()) {
+                value += stack2.pop();
+            }
+            int digit = value % 10;
+            carry = value / 10;
+            Node head = new Node(digit);
+            head.next = dummy.next; 
+            dummy.next = head;
+        }
+        return dummy.next;
     }
 }
 
 // Time/Space Complexity for both solutions
 //
-//  Time Complexity: O(n + m)
-// Space Complexity: O(n + m)
+//  Time Complexity: O(m + n)
+// Space Complexity: O(m + n)

Chp. 02 - Linked Lists/_2_5_Sum_Lists/SumLists.java

@@ -3,42 +3,52 @@
 import common.Node;
 import common.ListFunctions;
 
-import java.util.ArrayDeque;
-
 public class Palindrome {
     public static boolean palindrome(Node head) {
-        int size = ListFunctions.calculateSize(head);
-        ArrayDeque<Integer> deque = new ArrayDeque<>();
-        Node curr = head;
-        /* Save 1st half of list */
-        for (int i = 0; i < size / 2; i++) {
-            deque.push(curr.data);
-            curr = curr.next;
+        if (head == null) {
+            return false; // depends on our definition of a palindrome.
+        }
+
+        // Reverse 2nd half of list
+        Node slow = head;
+        Node fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
         }
-        /* If list had odd number of elements -> skip middle element */
-        if (size % 2 == 1) {
-            curr = curr.next;
+        if (fast != null) { // for lists with odd # of Nodes
+            slow = slow.next;
         }
-        /* Compare 2nd half of list to 1st half of list */
-        while (curr != null) {
-            if (deque.pop() != curr.data) {
+        Node slowCenter = ListFunctions.reverseListIterative(slow);
+
+        // compare 1st half of list to 2nd half
+        Node slowFront = head;
+        ListFunctions.printList(slowFront);
+        ListFunctions.printList(slowCenter);
+        
+        while (slowCenter != null) {
+            if (slowCenter.data != slowFront.data) {
                 return false;
             }
-            curr = curr.next;
+            slowFront = slowFront.next;
+            slowCenter = slowCenter.next;
         }
         return true;
     }
 }
 
 //  Time Complexity: O(n)
-// Space Complexity: O(n)
+// Space Complexity: O(1)
 
 
-// Alternate solution
+// Alternate solution - O(n) time, O(n) space
+//
+// 1. Save 1st half of list in stack
+// 2. Compare 2nd half of list to 1st half of list
+
+
+// Alternate solution - O(n) time, O(n) space
 //
 // 1. Deep copy list.
 // 2. Reverse it.
 // 3. Compare it to original.
-// 
-//  Time Complexity: O(n)
-// Space Complexity: O(n)