refactor 48

Author: fishercoder1534

README.md

@@ -570,7 +570,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |51|[N-Queens](https://leetcode.com/problems/n-queens/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_51.java)|O(?)|O(?)|Hard|
 |50|[Pow(x, n)](https://leetcode.com/problems/powx-n/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_50.java)|O(logn)|O(logn)|Medium|
 |49|[Group Anagrams](https://leetcode.com/problems/group-anagrams/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_49.java)|O(m*logn)|O(m*n)|Medium| HashMap
-|48|[Rotate Image](https://leetcode.com/problems/rotate-image/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_48.java)|O(n^2)|O(1)|Medium|Array
+|48|[Rotate Image](https://leetcode.com/problems/rotate-image/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_48.java)|O(n^2)|O(1)| Medium | Array
 |47|[Permutations II](https://leetcode.com/problems/permutations-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_47.java)|O(n*n!)|O(n)|Medium|Backtracking
 |46|[Permutations](https://leetcode.com/problems/permutations/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_46.java)|O(n*n!)|O(n)|Medium|Backtracking
 |45|[Jump Game II](https://leetcode.com/problems/jump-game-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_45.java)|O(?)|O(?)|Hard|

src/main/java/com/fishercoder/solutions/_48.java

@@ -12,57 +12,68 @@
  */
 public class _48 {
 
-    public void rotate_O1(int[][] matrix) {
-        /**First swap the elements on the diagonal, then reverse each row:
-         * 1, 2, 3                    1, 4, 7                      7, 4, 1
-         * 4, 5, 6         becomes    2, 5, 8           becomes    8, 5, 2
-         * 7, 8, 9                    3, 6, 9                      9, 6, 3
-         This is done in O(1) space!
-         **/
-        int m = matrix.length;
-        int n = matrix[0].length;
-        for (int i = 0; i < m; i++) {
-            for (int j = i; j < n; j++) {
-                /**ATTN: j starts from i, so that the diagonal changes with itself, no change.*/
-                int tmp = matrix[i][j];
-                matrix[i][j] = matrix[j][i];
-                matrix[j][i] = tmp;
+    /**Note: this is an n*n matrix, in other words, it's a square, this makes it easier as well.*/
+
+    public static class Solution1 {
+        public void rotate(int[][] matrix) {
+            /**First swap the elements on the diagonal, then reverse each row:
+             * 1, 2, 3                    1, 4, 7                      7, 4, 1
+             * 4, 5, 6         becomes    2, 5, 8           becomes    8, 5, 2
+             * 7, 8, 9                    3, 6, 9                      9, 6, 3
+             This is done in O(1) space!
+             **/
+            int m = matrix.length;
+            for (int i = 0; i < m; i++) {
+                for (int j = i; j < m; j++) {
+                    /**ATTN: j starts from i, so that the diagonal changes with itself, results in no change.*/
+                    int tmp = matrix[i][j];
+                    matrix[i][j] = matrix[j][i];
+                    matrix[j][i] = tmp;
+                }
             }
-        }
 
-        for (int i = 0; i < m; i++) {
-            for (int j = 0; j < n / 2; j++) {
-                int tmp = matrix[i][j];
-                matrix[i][j] = matrix[i][n - 1 - j];
-                matrix[i][n - 1 - j] = tmp;
+            /**then reverse*/
+            for (int i = 0; i < m; i++) {
+                int left = 0;
+                int right = m - 1;
+                while (left < right) {
+                    int tmp = matrix[i][left];
+                    matrix[i][left] = matrix[i][right];
+                    matrix[i][right] = tmp;
+                    left++;
+                    right--;
+                }
             }
         }
     }
 
-    /**First swap the rows bottom up, then swap the element on the diagonal:
-     * 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
-     * */
-    /**This is using O(n) of extra space*/
-    public void rotate_On(int[][] matrix) {
-        int m = matrix.length;
-        int n = matrix[0].length;
-        int top = 0;
-        int bottom = n - 1;
-        while (top < bottom) {
-            int[] tmp = matrix[top];
-            matrix[top] = matrix[bottom];
-            matrix[bottom] = tmp;
-            top++;
-            bottom--;
-        }
+    public static class Solution2 {
+        /**First swap the rows bottom up, then swap the element on the diagonal:
+         * 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
+         *
+         *  This is using O(n) of extra space
+         */
+        public void rotate(int[][] matrix) {
+            int m = matrix.length;
+            int n = matrix[0].length;
+            int top = 0;
+            int bottom = n - 1;
+            while (top < bottom) {
+                int[] tmp = matrix[top];
+                matrix[top] = matrix[bottom];
+                matrix[bottom] = tmp;
+                top++;
+                bottom--;
+            }
 
-        for (int i = 0; i < m; i++) {
-            for (int j = i + 1; j < n; j++) {
-                int tmp = matrix[i][j];
-                matrix[i][j] = matrix[j][i];
-                matrix[j][i] = tmp;
+            for (int i = 0; i < m; i++) {
+                for (int j = i + 1; j < n; j++) {
+                    int tmp = matrix[i][j];
+                    matrix[i][j] = matrix[j][i];
+                    matrix[j][i] = tmp;
+                }
             }
         }
     }

src/test/java/com/fishercoder/_48Test.java

@@ -1,5 +1,6 @@
 package com.fishercoder;
 
+import com.fishercoder.common.utils.CommonUtils;
 import com.fishercoder.solutions._48;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -8,12 +9,14 @@
  * Created by fishercoder on 5/8/17.
  */
 public class _48Test {
-    private static _48 test;
+    private static _48.Solution1 solution1;
+    private static _48.Solution2 solution2;
     private static int[][] matrix;
 
     @BeforeClass
     public static void setup() {
-        test = new _48();
+        solution1 = new _48.Solution1();
+        solution2 = new _48.Solution2();
     }
 
     @Test
@@ -23,6 +26,18 @@ public void test1() {
                 {4, 5, 6},
                 {7, 8, 9},
         };
-        test.rotate_On(matrix);
+        solution1.rotate(matrix);
+        CommonUtils.print2DIntArray(matrix);
+    }
+
+    @Test
+    public void test2() {
+        matrix = new int[][]{
+                {1, 2, 3},
+                {4, 5, 6},
+                {7, 8, 9},
+        };
+        solution2.rotate(matrix);
+        CommonUtils.print2DIntArray(matrix);
     }
 }