Update matrix algorithms

Author: sudheerj

README.md

@@ -4,9 +4,12 @@ List of Programs related to data structures and algorithms
 ## Data Structures
 
 ### Stack
-   1. Stack using array: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/stack_with_array.js)
 
-   2. Stack using linkedlist: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/stack_with_linkedlist.js)
+| No. | Name              |                                                               Source                                                                | Live                                                                                                                                                                         |                                                               Documentation                                                                | Level |        Pattern         |
+| :-: | :---------------- | :---------------------------------------------------------------------------------------------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------: | :---: | :--------------------: |
+|  1  | Stack using array | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/1.stack_with_array/stack_with_array.js) | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/1.stack_with_array//stack_with_array.js) | -<!--[Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/1.stack_with_array//stack_with_array.md) --> | Easy  | Using Array operations |
+| 2    | Stack using linkedlist                  |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/2.stack_with_linkedlist/stack_with_linkedlist.js)                                                                                                                                    |  [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/2.stack_with_linkedlist/stack_with_linkedlist.js)                                                                                                                                                                             |  -<!--[Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/stack/2.stack_with_linkedlist/stack_with_linkedlist.md) -->                                                                                                                                          | Easy      |   Using LinkedList operations                     |
+
 
 ### Queue
    1. Queue using array: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/queue_array.js)
@@ -166,14 +169,13 @@ List of Programs related to data structures and algorithms
 |  7  | Number of connected components in an undirected graph         | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/7.numberOfConnectedComponents/numberOfConnectedComponents.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/7.numberOfConnectedComponents/numberOfConnectedComponents.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/7.numberOfConnectedComponents/numberOfConnectedComponents.md) | Medium       |    Union Find algorithm(+ union by rank & path compression)                               |
 
 ### Matrix
+| No. | Name             |                                                                      Source                                                                       | Live                                                                                                                                                                                  |                                                                                  Documentation                                                                                  | Level  |              Pattern               |
+| :-: | :--------------- | :-----------------------------------------------------------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :--------------------------------: |
+|  1  | Set matrix zeros | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/1.setMatrixZeroes/setMatrixZeroes.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/1.setMatrixZeroes/setMatrixZeroes.js) |            [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/1.setMatrixZeroes/setMatrixZeroes.md)             | Medium | In-place updates through traversal |
+| 2.  | Spiral matrix    |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/2.spiralMatrix/spiralMatrix.js)  | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/2.spiralMatrix/spiralMatrix.js)       | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/2.spiralMatrix/spiralMatrix.md) | Medium |     Boundary matrix traversal/spiral pattern      |
+|  3  | Rotate image     |     [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/3.rotateImage/rotateImage.js)     | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/3.rotateImage/rotateImage.js)         |                [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/3.rotateImage/rotateImage.md)                 | Medium |    Inplace square rotation                                |
+| 4 |  Word search                | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/4.wordSearch/wordSearch.js)                                                                                                                                                  |  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/4.wordSearch/wordSearch.js)                                                                                                                                                                                     | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/4.wordSearch/wordSearch.md)                                                                                                                                                                                    | Medium       |  Depth-First Search (DFS) using recursion                                  |
 
-   1. Set matrix zeros: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/setMatrixZeros.js)
-
-   2. Spiral matrix: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/spiralMatrix.js)
-
-   3. Rotate image: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/rotateImage.js)
-
-   4. Word search: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/matrix/wordSearch.js)
 
 ### Interval
 

src/images/rotate-image1.png

@@ -1,9 +1,9 @@
-package java1.algorithms.matrix;
+package java1.algorithms.matrix.rotateImage;
 
 import java.util.Arrays;
 
 public class RotateImage {
-    // TC: O(n*2) SC: O(1)
+    // TC: O(n^2) SC: O(1)
     private static void rotate(int[][] matrix) {
         int left =0, right = matrix[0].length-1;
 
@@ -32,13 +32,26 @@ private static void rotate(int[][] matrix) {
     }
 
     public static void main(String[] args) {
-        int[][] matrix = {
+        int[][] matrix1 = {
+            {1, 2},
+            {3, 4}
+        };
+        int[][] matrix2 = {
+            {1,2,3},
+            {4,5,6},
+            {7,8,9}
+        };
+        int[][] matrix3 = {
             {1, 2, 3, 4}, 
             {5, 6, 7, 8},
             {9, 10, 11, 12}, 
             {13, 14, 15, 16}
         };
-        rotate(matrix);
-        System.out.println(Arrays.deepToString(matrix));
+        rotate(matrix1);
+        rotate(matrix2);
+        rotate(matrix3);
+        System.out.println(Arrays.deepToString(matrix1));
+        System.out.println(Arrays.deepToString(matrix2));
+        System.out.println(Arrays.deepToString(matrix3));
     }
 }

src/images/rotate-image2.png

@@ -0,0 +1,82 @@
+**Problem statement:**
+Given an `n x n` square matrix of integers `matrix`, rotate it by 90 degrees clockwise.
+
+**Note:** You must rotate the matrix in-place without allocating another 2D matrix to do the rotation.
+
+## Examples:
+Example1:
+
+Input: matrix = [
+    [1,2],
+    [3,4]
+  ]
+
+Output: [
+    [3, 1],
+    [4, 2]
+]
+
+
+![Screenshot](../../../../images/rotate-image1.png)
+
+Example2:
+
+Input: matrix = [
+    [1,2,3],
+    [4,5,6],
+    [7,8,9]
+ ]
+
+Output: [  
+  [7,4,1],
+  [8,5,2],
+  [9,6,3]
+]
+
+![Screenshot](../../../../images/rotate-image2.png)
+
+Example3:
+
+Input: matrix = [
+    [1,2,3],
+    [4,5,6],
+    [7,8,9]
+]
+
+Output: [  
+    [1, 2, 3, 4], 
+    [5, 6, 7, 8],
+    [9, 10, 11, 12], 
+    [13, 14, 15, 16]
+]
+
+![Screenshot](../../../../images/rotate-image3.png)
+
+
+**Algorithmic Steps**
+This problem is solved by inplace square rotation technique in which corner cells of a square rotated by 90 degress in a clockwise direction. Moreover, the rotation starts from bottom left cell and one extra variable is used to store the previous value of top left cell value. The algorithmic approach can be summarized as follows: 
+
+![Screenshot](../../../../images/rotate-image4.png)
+
+1. Create a function(`rotateImage`) by accepting the `n*n` matrix as input parameter.
+   
+2. Define two pointers `left` and `right` point to first and last column indexes. They are helpful to traverse over the cells.
+
+3. Traverse over each cell until left pointer is less than equals to right pointer.
+
+   1. Add a nested loop `n-1`(i.e, `right-left`) times to update the cell values by 90 degrees.
+        1. Store the top left cell's value in a temporary variable(`topLeft`) before it is going to updated.
+        2. Move bottom left value to top left cell's position.
+        3. Move bottom right value to bottom left cell's position.
+        4. Move top right value to bottom right cell's position.
+        5. Copy top left temporary variable to top right cell's position.
+   
+   2. Increment left pointer by 1 and decrement right pointer by 1 upon completion of one full rotation.
+   
+4. Repeat the rotation until all the cells rotated by 90 degrees. i.e, left pointer is less than right pointer.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n^2))`, where `n` is the number of rows or the number of columns in the given matrix. This is because each element needs to moved exactly once.
+
+It requires `O(1)` constant space complexity irrespective of the matrix size. This is becuase we don't need to use any additional temporary space(except a pointer variable) considering inplace matrix update.

src/images/rotate-image3.png

@@ -1,8 +1,8 @@
-package java1.algorithms.matrix;
+package java1.algorithms.matrix.setMatrixZeroes;
 import java.util.*;
 
-public class SetMatrixZeros {
-    //TC: O(rows*cols) SC:O(1)
+public class SetMatrixZeroes {
+    //TC: O(m*n) SC:O(1)
     private static void setZeros(int[][] matrix) {
         int rows = matrix.length, cols = matrix[0].length;
         boolean rowZero = false;
@@ -30,7 +30,7 @@ private static void setZeros(int[][] matrix) {
         }
 
         if(matrix[0][0] == 0) {
-            for(int r=0; r<rows; r++) {
+            for(int r=1; r<rows; r++) {
                 matrix[r][0] = 0;
             }
         }
@@ -44,10 +44,15 @@ private static void setZeros(int[][] matrix) {
     }
 
     public static void main(String[] args) {
-        int[][] matrix = {
+        int[][] matrix1 = {
             {1, 0, 1}, {1, 0, 1}, {0, 1, 1}
         };
-        setZeros(matrix);
-       System.out.println(Arrays.deepToString(matrix));
+        int[][] matrix2 = {
+            {1, 2, 3}, {4, 0, 6}, {7, 8, 9}
+        };
+        setZeros(matrix1);
+        setZeros(matrix2);
+        System.out.println(Arrays.deepToString(matrix1));
+        System.out.println(Arrays.deepToString(matrix2));
     }
 }

src/images/rotate-image4.png

@@ -0,0 +1,55 @@
+**Problem statement:**
+Given an `m x n` matrix of integers `matrix`, if an element is `0`, set its entire row and column to `0`'s.
+
+**Note:** You must update the matrix in-place using constant space solution(`O(1)`).
+
+## Examples:
+Example1:
+
+Input: matrix = [
+[1, 0, 1], [1, 0, 1], [0, 1, 1]
+]
+
+Output: [
+  [0,0,0],
+  [0,0,0],
+  [0,0,0]
+]
+
+![Screenshot](../../../../images/set-matrix-zeros1.png)
+
+Example2:
+
+Input: matrix = [
+[1, 2, 3], [4, 0, 6], [7, 8, 9]
+]
+
+Output: [
+[1, 0, 3], [0, 0, 0], [7, 0, 9]
+]
+
+![Screenshot](../../../../images/set-matrix-zeros2.png)
+
+
+**Algorithmic Steps**
+This problem is solved by in-place alogorithm in which first row and first column of given matrix acts as markers for setting zeroes in cells. Since the first cell is used to track the first column zeros, we need to take an extra boolean marker for first row zeroes. The algorithmic approach can be summarized as follows: 
+
+1. Create a function(`setZeroes`) by accepting the `m*n` matrix as input parameter.
+   
+2. Store the number of rows(`rows`) and columns(`cols`) of a matrix for iteration purpose. The first row and first column acts as markers to indicate which rows and columns should set to zero. The boolean marker `rowZero` is used as a zero marker for first row because the first cell is used as marker for first column cells.
+
+3. Iterate over each cell of a matrix to mark which columns and rows to be set to zero,
+    1. If the cell value is zero, set the respective column's first row value to zero. 
+    2. If the cell's row is greater than zero, set the respective row's first column value to zero.
+    3. Otherwise, set `rowZero` to `true` indicating that first row marked for zeros.
+   
+4. Iterate each cell again except first row and first column, set the cell value to zero based on first row and first column values.
+
+5. Set zeros to first column if first cell's value is zero.
+6. Set zeros to first row if the boolean marker `rowZero` is `true`. 
+7. At this stage, given matrix is updated with zeros for respective rows and columns without using additional space.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(m*n))`, where `m` is the number of rows and `n` is the number of columns in the given matrix. This is because each cell visited twice, once to mark the rows and columns that should be set to zero and once to actually set the zeroes in cells.
+
+It requires `O(1)` constant space complexity irrespective of the matrix size. This is becuase it uses only one variable(`rowZero`),which is used to mark the first row cells to be zero or not.

src/images/set-matrix-zeros1.png

@@ -0,0 +1,62 @@
+package java1.algorithms.matrix.spiralMatrix;
+
+import java.util.*;
+
+public class SpiralMatrix {
+    // TC: O(m*n) SC: O(1)
+    private static List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> traversal = new ArrayList<>();
+        int left =0, right = matrix[0].length-1;
+        int top =0, bottom= matrix.length-1;
+
+        while(left <= right && top <= bottom) {
+            // Top row elements
+            for(int i=left; i<=right; i++) {
+                traversal.add(matrix[top][i]);
+            }
+
+            top++;
+
+            // Last column elements
+            for(int i=top; i<=bottom; i++) {
+                traversal.add(matrix[i][right]);
+            }
+
+            right--;
+
+            if(left<=right && top<=bottom) {
+                // Last row elements
+                for(int i= right; i>=left; i--) {
+                    traversal.add(matrix[bottom][i]);
+                }
+
+                bottom--;
+
+                // First column elements
+                for(int i= bottom; i>=top; i--) {
+                    traversal.add(matrix[i][left]);
+                }
+
+                left++;
+            }
+
+        }
+        return traversal;
+    }
+
+    public static void main(String[] args) {
+        int[][] matrix1 = {
+            {1, 2}, {3, 4}
+        };
+        int[][] matrix2 = {
+            {1, 2, 3}, {4, 5, 6}, {7, 8, 9}
+        };
+        int[][] matrix3 = {
+            {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}
+        };
+        
+        System.out.println(spiralOrder(matrix1));
+        System.out.println(spiralOrder(matrix2));
+        System.out.println(spiralOrder(matrix3));
+    }
+}