All 15 Arrays & Multidimensional Arrays questions
More in Arrays & Multidimensional Arrays
What is array covariance's relationship to generic arrays, and why can't you directly create a generic array like new T[10] or new List<String>[10]? How would you flatten a 2D array into a 1D array, and conversely, reshape a 1D array into a 2D array? How does Java implement covariant array typing, and why is this considered a design flaw that can lead to runtime ArrayStoreException? How would you efficiently copy, resize, or merge large arrays in Java, and what are the performance trade-offs between System.arraycopy(), Arrays.copyOf(), and manual loops? How would you implement a custom, resizable dynamic array (similar to ArrayList's internal mechanism) from scratch using a raw Java array, including the amortized doubling growth strategy? How would you implement a memory-efficient sparse matrix representation in Java when a large 2D array would mostly contain zero/default values, avoiding the memory waste of a full dense array? How does the JVM lay out array objects in memory, including the array header overhead, and how does this affect memory efficiency for very large arrays of primitives versus boxed wrapper types?
Advertisement
Java › Arrays & Multidimensional Arrays

How would you implement an efficient in-place algorithm on a 2D array, such as rotating a matrix 90 degrees, while minimizing extra memory allocation?

Advanced

Answer

An in-place rotation can be achieved through a combination of transposing the matrix (swapping matrix[i][j] with matrix[j][i] across the diagonal) followed by reversing each row (or column, depending on rotation direction), avoiding the need to allocate an entirely new matrix -- this two-step decomposition is a classic technique that reduces an seemingly complex 2D transformation into two simpler, well-understood O(n²) operations performed directly on the existing array structure.
public static void rotate90Clockwise(int[][] matrix) {
    int n = matrix.length;
    // Step 1: transpose in place
    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[] row : matrix) {
        for (int left = 0, right = row.length - 1; left < right; left++, right--) {
            int temp = row[left];
            row[left] = row[right];
            row[right] = temp;
        }
    }
}
Real-world example An image-processing utility rotating a pixel matrix representing a small icon uses the transpose-then-reverse in-place technique to avoid allocating a second full-size matrix, meaningful for memory-constrained environments processing many images where allocation overhead would otherwise add up significantly.

Common follow-ups: What's the time and space complexity of this in-place approach compared to a naive approach allocating a new rotated matrix?;How would this algorithm need to change for a non-square (rectangular) matrix?

Diagnostics & Performance;Garbage Collection
All 15 Arrays & Multidimensional Arrays questions