48. Rotate Image

Author: jiangyong07

src/main/java/joshua/leetcode/array/RotateArray189.java

@@ -2,85 +2,81 @@
 
 public abstract class RotateArray189 {
 
-	/**
-	 * Rotate an array of n elements to the right by k steps.
+    /**
+     * Rotate an array of n elements to the right by k steps.
+     * <p/>
+     * For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].
+     */
 
-	   For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].
-	 */
-	
-	 public abstract void rotate(int[] nums, int k);
+    public abstract void rotate(int[] nums, int k);
 
-	 static class Solution1 extends RotateArray189{
+    static class Solution1 extends RotateArray189 {
 
-		 public void swap(int[] a, int i, int j)
-		 {
-		     int temp = a[i];
-		     a[i] = a[j];
-		     a[j] = temp;
-		 }
+        public void swap(int[] a, int i, int j) {
+            int temp = a[i];
+            a[i] = a[j];
+            a[j] = temp;
+        }
 
-		  /**
-		   * for example, array:[1,2,3,4,5,6], step=2
-		   * the steps will be:
-		   * [1,6,3,4,5,2], idx=1, temp=5
-		   * [1,6,3,2.5.4], idx=3, temp=5
-		   * [1,6,3,2,5,4], idx=(3+2)%6=5==temp, so temp=temp-1=4, idx=4, no element moved in this iteration
-		   * [5,6,3,2,1,4], idx=0, temp=4
-		   * [5,6,1,2,3,4], idx=2, temp=4, iteration exit.
-		   */
-		  public void rotate(int[] a, int k)
-		  {
-		     int N = a.length;
-		     k = k%N;
-		     int idx = N-1;
-		     int temp = N-1;
-		     /**
-		      * every step will swap two element, within which one element gets the final position.
-		      * So in total it only needs N-1 step.
-		      */
-		     for (int s = 0; s < N-1; s++)
-		     {
-		             idx = (idx+k)%N;            
-		             if(temp == idx)
-		             {
-		                 temp = temp-1;
-		                 idx = temp;
-		                 continue; 
-		             }
-		             /*idx is now the final position of element at position temp*/
-		             swap(a,temp,idx);           
-		     }
-		  }
-	 }
-	 
-	 static class Solution2 extends RotateArray189{
+        /**
+         * for example, array:[1,2,3,4,5,6], step=2
+         * the steps will be:
+         * [1,6,3,4,5,2], idx=1, temp=5
+         * [1,6,3,2.5.4], idx=3, temp=5
+         * [1,6,3,2,5,4], idx=(3+2)%6=5==temp, so temp=temp-1=4, idx=4, no element moved in this iteration
+         * [5,6,3,2,1,4], idx=0, temp=4
+         * [5,6,1,2,3,4], idx=2, temp=4, iteration exit.
+         */
+        public void rotate(int[] a, int k) {
+            int N = a.length;
+            k = k % N;
+            int idx = N - 1;
+            int temp = N - 1;
+            /**
+             * every step will swap two element, within which one element gets the final position.
+             * So in total it only needs N-1 step.
+             */
+            for (int s = 0; s < N - 1; s++) {
+                idx = (idx + k) % N;
+                if (temp == idx) {
+                    temp = temp - 1;
+                    idx = temp;
+                    continue;
+                }
+                /*idx is now the final position of element at position temp*/
+                swap(a, temp, idx);
+            }
+        }
+    }
 
-		 /**
-		  * example [1,2,3,4,5,6,7], step=3
-		  * 
-		  * rotate the [1,2,3,4] firstly as [4,3,2,1,5,6,7]
-		  * rotate the [5,6,7] secondly as [4,3,2,1,7,6,5]
-		  * rotate the whole array as [5,6,7,1,2,3,4]
-		  */
-		@Override
-		public void rotate(int[] nums, int k) {
-				k=k%nums.length;
-				rotate(nums,0,nums.length-k-1);
-				rotate(nums,nums.length-k,nums.length-1);
-				rotate(nums,0,nums.length-1);
-		}
-		
-		private void rotate(int[] nums, int start, int end){
-			while(start<end){
-				  nums[start] ^= nums[end];
-	              nums[end] ^= nums[start];
-	              nums[start] ^= nums[end];
-	              start++;
-	              end--;
-			}
-		}
-		 
-	 }
+    static class Solution2 extends RotateArray189 {
+
+        /**
+         * example [1,2,3,4,5,6,7], step=3
+         * <p/>
+         * rotate the [1,2,3,4] firstly as [4,3,2,1,5,6,7]
+         * rotate the [5,6,7] secondly as [4,3,2,1,7,6,5]
+         * rotate the whole array as [5,6,7,1,2,3,4]
+         */
+        @Override
+        public void rotate(int[] nums, int k) {
+            k = k % nums.length;
+            rotate(nums, 0, nums.length - k - 1);
+            rotate(nums, nums.length - k, nums.length - 1);
+            rotate(nums, 0, nums.length - 1);
+        }
+
+        private void rotate(int[] nums, int start, int end) {
+            while (start < end) {
+                nums[start] ^= nums[end];
+                nums[end] ^= nums[start];
+                nums[start] ^= nums[end];
+                start++;
+                end--;
+            }
+        }
+
+    }
 }
 
 

src/main/java/joshua/leetcode/array/RotateImage.java

@@ -0,0 +1,61 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.array;
+
+/**
+ * 48. Rotate Image<br>
+ * <a href="https://leetcode.com/problems/rotate-image/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class RotateImage {
+
+    /**
+     * You are given an n x n 2D matrix representing an image.
+     * <p/>
+     * Rotate the image by 90 degrees (clockwise).
+     * <p/>
+     * Follow up:
+     * <b>Could you do this in-place?</b>
+     *
+     * @param matrix
+     */
+    public abstract void rotate(int[][] matrix);
+
+    /**
+     * 可以从外到内，分层旋转。关键是厘清所有的下标转换。以大小为4*4的矩阵为例。
+     * (0,0),(0,1),(0,2),(0,3)
+     * (1,0),(1,1),(1,2),(1,3)
+     * (2,0),(2,1),(2,2),(2,3)
+     * (3,0),(3,1),(3,2),(3,3)
+     * 最外层,上下界为min = 0和 max = 3，旋转为:
+     * 上 -> 右 -> 下 -> 左 - > 上， 从上面的元素开始，(min,min) 到 (min,max-1), 记 i begins with min ,ends with max-1.
+     * (0,0) -> (0,3) -> (3,3) -> (3,0) -> (0,0)， i = 0
+     * (0,1) -> (1,3) -> (3,2) -> (2,0) -> (0,1)， i = 1
+     * (0,2) -> (2,3) -> (3,1) -> (1,0) -> (0,2)， i = 2
+     */
+    public static class Solution1 extends RotateImage {
+
+        @Override
+        public void rotate(int[][] matrix) {
+            int size = matrix.length;
+            for (int layer = 0; layer < size / 2; layer ++) {
+                int min = layer;
+                int max = size -1 - layer;
+                for(int i = min; i < max ; i++) {
+                    int offset = i - min;
+                    // save top
+                    int top = matrix[min][i];// begins with (min,min), end with (min, max -1)
+                    // left to top
+                    matrix[min][i] = matrix[max - offset][min];
+                    // bottom to left
+                    matrix[max - offset][min] = matrix[max][max - offset];
+                    //right to bottom
+                    matrix[max][max - offset] = matrix[i][max];
+                    //top to right
+                    matrix[i][max] = top;
+                }
+            }
+        }
+    }
+}

src/test/java/joshua/leetcode/array/RotateImageTest.java

@@ -0,0 +1,38 @@
+package joshua.leetcode.array;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RotateImageTest {
+
+
+    private int[][] matrix;
+
+    @Before
+    public void setUp() {
+        matrix = new int[][]{
+                {0, 1, 2, 3},
+                {4, 5, 6, 7},
+                {8, 9, 10, 11},
+                {12, 13, 14, 15}};
+//        matrix = new int[][]{
+//                {0, 1},
+//                {4, 5}};
+    }
+
+    @Test
+    public void testSolution1() {
+        RotateImage image = new RotateImage.Solution1();
+        image.rotate(matrix);
+        System.out.println(ArrayUtils.toString(image));
+        for (int i =0; i< matrix.length; i++) {
+            for(int j = 0; j<matrix[0].length;j++) {
+                System.out.print(matrix[i][j]);
+                System.out.print("\t");
+            }
+            System.out.print("\n");
+        }
+    }
+
+}