Write a Java program to rotate arrays 90 degree clockwise by taking matrices from user input.

To rotate a matrix 90 degrees clockwise in Java, we can utilize an in-place rotation technique. This method involves two main steps: transposing the matrix and then reversing each row. Here's how you can implement it:

1. Transpose the Matrix: Swap elements across the diagonal. For a matrix matrix[i][j], swap it with matrix[j][i].
2. Reverse Each Row: After transposing, reverse each row to achieve the final rotated matrix.

Here’s the code:

public void rotate(int[][] matrix) {
    int n = matrix.length;
    // Step 1: Transpose the matrix
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
    // Step 2: Reverse each row
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n / 2; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[i][n - 1 - j];
            matrix[i][n - 1 - j] = temp;
        }
    }
}

This approach has a time complexity of O(n^2) and a space complexity of O(1), making it efficient for rotating matrices.

An alternative approach to rotate a matrix 90 degrees clockwise is to create a new matrix. This method is straightforward but uses additional space. Here’s how you can do it:

1. Create a New Matrix: Allocate a new matrix of the same size.
2. Fill the New Matrix: Iterate through the original matrix and place each element in the new matrix at its rotated position.

Here’s the implementation:

public void rotate(int[][] matrix) {
    int n = matrix.length;
    int[][] rotated = new int[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            rotated[j][n - 1 - i] = matrix[i][j];
        }
    }
    // Copy back to original matrix
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            matrix[i][j] = rotated[i][j];
        }
    }
}

This method has a time complexity of O(n^2) and a space complexity of O(n^2) due to the additional matrix, which may not be optimal for large datasets but is easier to understand for beginners.

If you need to rotate a non-square matrix, the approach changes slightly because you cannot directly use the methods designed for square matrices. In this case, you will need to:

1. Create a New Matrix: Allocate a new matrix with dimensions flipped (rows become columns and vice versa).
2. Fill the New Matrix: Place elements according to the rotation logic.

Here’s how you can implement this:

public int[][] rotateNonSquare(int[][] matrix) {
    int rows = matrix.length;
    int cols = matrix[0].length;
    int[][] rotated = new int[cols][rows];
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            rotated[j][rows - 1 - i] = matrix[i][j];
        }
    }
    return rotated;
}

This function returns a new rotated matrix. The time complexity remains O(n * m) where n is the number of rows and m is the number of columns, and the space complexity is also O(n * m) for the new matrix. This method is essential when dealing with dynamic data structures, such as user-generated matrices.