refactor 48

fishercoder1534 · fishercoder1534 · commit 56d29498afc8 · 2021-10-12T15:00:07.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_48.java b/src/main/java/com/fishercoder/solutions/_48.java
@@ -4,7 +4,9 @@
 
 public class _48 {
 
-    /**Note: this is an n*n matrix, in other words, it's a square, this makes it easier as well.*/
+    /**
+     * Note: this is an n*n matrix, in other words, it's a square, this makes it easier as well.
+     */
 
     public static class Solution1 {
         //Time: O(n^2)
@@ -42,12 +44,13 @@ public void rotate(int[][] matrix) {
     }
 
     public static class Solution2 {
-        /**First swap the rows bottom up, then swap the element on the diagonal:
-         *
+        /**
+         * First swap the rows bottom up, then swap the element on the diagonal:
+         * <p>
          * 1, 2, 3                         7, 8, 9                           7, 4, 1
          * 4, 5, 6           becomes       4, 5, 6           becomes         8, 5, 2
          * 7, 8, 9                         1, 2, 3                           9, 6, 3
-         *
+         * <p>
          * Time: O(n^2)
          * Space: O(1)
          */
@@ -75,23 +78,43 @@ public void rotate(int[][] matrix) {
     }
 
     public static class Solution3 {
+        /**
+         * You only need to rotate the top right quarter,
+         * with this example:
+         * {1, 2, 3, 4},
+         * {5, 6, 7, 8},
+         * {9, 10, 11, 12},
+         * {13, 14, 15, 16}
+         *
+         * top will only be:
+         * 1, 2, 3,
+         * 6
+         *
+         * then this entire matrix is rotated. As they'll drive to ratate the corresponding three elements in the matrix.
+         *
+         * Another cool trick that this solution takes advantage is that because it's a square matrix,
+         * meaning number of rows equals to the number of columns, we could do swap like this,
+         * if it's a rectangular, below method won't work and will throw ArrayIndexOutOfBoundsException.
+         *
+         */
         public void rotate(int[][] matrix) {
             int n = matrix.length;
             for (int i = 0; i < n / 2; i++) {
                 for (int j = i; j < n - i - 1; j++) {
-                    //save the top
+                    //save the top left
                     int top = matrix[i][j];
+                    System.out.println("top = " + top);
 
-                    //move left to top
+                    //move bottom left to top left
                     matrix[i][j] = matrix[n - 1 - j][i];
 
-                    //move bottom to left
+                    //move bottom right to bottom left
                     matrix[n - 1 - j][i] = matrix[n - i - 1][n - 1 - j];
 
-                    //move right to bottom
+                    //move top right to bottom right
                     matrix[n - i - 1][n - 1 - j] = matrix[j][n - i - 1];
 
-                    //move top to right
+                    //move top left to top right
                     matrix[j][n - i - 1] = top;
                 }
             }
diff --git a/src/test/java/com/fishercoder/_48Test.java b/src/test/java/com/fishercoder/_48Test.java
@@ -70,6 +70,7 @@ public void test5() {
                 {9, 10, 11, 12},
                 {13, 14, 15, 16}
         };
+        CommonUtils.print2DIntArray(matrix);
         solution3.rotate(matrix);
         CommonUtils.print2DIntArray(matrix);
     }
@@ -85,4 +86,5 @@ public void test6() {
         solution1.rotate(matrix);
         CommonUtils.print2DIntArray(matrix);
     }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,7 @@ public void test5() {`
`70`	`70`	`{9, 10, 11, 12},`
`71`	`71`	`{13, 14, 15, 16}`
`72`	`72`	`};`
	`73`	`+ CommonUtils.print2DIntArray(matrix);`
`73`	`74`	`solution3.rotate(matrix);`
`74`	`75`	`CommonUtils.print2DIntArray(matrix);`
`75`	`76`	`}`
`@@ -85,4 +86,5 @@ public void test6() {`
`85`	`86`	`solution1.rotate(matrix);`
`86`	`87`	`CommonUtils.print2DIntArray(matrix);`
`87`	`88`	`}`
	`89`	`+`
`88`	`90`	`}`