Package g0001_0100.s0048_rotate_image

Class Solution

java.lang.Object
g0001_0100.s0048_rotate_image.Solution
public class Solution extends java.lang.Object
48 - Rotate Image.

Medium

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Example 1:

Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]

Output: [[7,4,1],[8,5,2],[9,6,3]]

Example 2:

Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]

Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

Example 3:

Input: matrix = [[1]]

Output: 1

Example 4:

Input: matrix = [[1,2],[3,4]]

Output: [[3,1],[4,2]]

Constraints:

  • matrix.length == n
  • matrix[i].length == n
  • 1 <= n <= 20
  • -1000 <= matrix[i][j] <= 1000

To solve the “Rotate Image” problem in Java with a Solution class, we can follow these steps:

  1. Define a Solution class.
  2. Define a method named rotate that takes a 2D array matrix representing an image as input and rotates the image by 90 degrees clockwise.
  3. Determine the number of layers in the matrix, which is equal to half of the matrix’s size.
  4. Iterate through each layer from outer to inner layers.
  5. For each layer:
    • Iterate through each element in the current layer.
    • Swap the elements of the current layer in a clockwise manner.
  6. Return the rotated matrix.

Here’s the implementation:

public class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        int layers = n / 2;

        for (int layer = 0; layer < layers; layer++) {
            int first = layer;
            int last = n - 1 - layer;
            
            for (int i = first; i < last; i++) {
                int offset = i - first;
                int top = matrix[first][i];
                
                // Move left to top
                matrix[first][i] = matrix[last - offset][first];
                
                // Move bottom to left
                matrix[last - offset][first] = matrix[last][last - offset];
                
                // Move right to bottom
                matrix[last][last - offset] = matrix[i][last];
                
                // Move top to right
                matrix[i][last] = top;
            }
        }
    }
}

This implementation provides a solution to the “Rotate Image” problem in Java. It rotates the given 2D matrix representing an image by 90 degrees clockwise in-place.

  • Constructor Summary

    Constructors
    Constructor
    Description
    Solution()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    rotate(int[][] matrix)
     

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • Solution

      public Solution()

  • Method Details

    • rotate

      public void rotate(int[][] matrix)