feat: add Rotate Image solution

- Transpose + reverse algorithm implementation
- Multiple approaches: Layer by Layer, Four-way Swap, Iterative
- O(n²) time, O(1) space complexity
- Comprehensive solutions and optimizations

Author: TechnoBlogger14o3

neetcode-150/math-geometry/rotate-image/solution.java

@@ -0,0 +1,187 @@
+/**
+ * Time Complexity: O(n²) - Two passes
+ * Space Complexity: O(1) - In-place modification
+ */
+class Solution {
+    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; 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++) {
+            int left = 0, right = n - 1;
+            while (left < right) {
+                int temp = matrix[i][left];
+                matrix[i][left] = matrix[i][right];
+                matrix[i][right] = temp;
+                left++;
+                right--;
+            }
+        }
+    }
+}
+
+// Alternative approach using layer by layer rotation
+class SolutionLayerByLayer {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        
+        for (int layer = 0; layer < n / 2; layer++) {
+            int first = layer;
+            int last = n - 1 - layer;
+            
+            for (int i = first; i < last; i++) {
+                int offset = i - first;
+                
+                // Save top
+                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;
+            }
+        }
+    }
+}
+
+// Alternative approach using four-way swap
+class SolutionFourWaySwap {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        
+        for (int i = 0; i < n / 2; i++) {
+            for (int j = i; j < n - 1 - i; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[n - 1 - j][i];
+                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
+                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
+                matrix[j][n - 1 - i] = temp;
+            }
+        }
+    }
+}
+
+// Alternative approach using iterative
+class SolutionIterative {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        
+        // Transpose
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[j][i];
+                matrix[j][i] = temp;
+            }
+        }
+        
+        // Reverse rows
+        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;
+            }
+        }
+    }
+}
+
+// Alternative approach using while loop
+class SolutionWhileLoop {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        
+        // Transpose
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[j][i];
+                matrix[j][i] = temp;
+            }
+        }
+        
+        // Reverse rows
+        for (int i = 0; i < n; i++) {
+            int left = 0, right = n - 1;
+            while (left < right) {
+                int temp = matrix[i][left];
+                matrix[i][left] = matrix[i][right];
+                matrix[i][right] = temp;
+                left++;
+                right--;
+            }
+        }
+    }
+}
+
+// Alternative approach using enhanced for loop
+class SolutionEnhancedForLoop {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        
+        // Transpose
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[j][i];
+                matrix[j][i] = temp;
+            }
+        }
+        
+        // Reverse rows
+        for (int i = 0; i < n; i++) {
+            int left = 0, right = n - 1;
+            while (left < right) {
+                int temp = matrix[i][left];
+                matrix[i][left] = matrix[i][right];
+                matrix[i][right] = temp;
+                left++;
+                right--;
+            }
+        }
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        
+        // Transpose
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[j][i];
+                matrix[j][i] = temp;
+            }
+        }
+        
+        // Reverse rows
+        for (int i = 0; i < n; i++) {
+            int left = 0, right = n - 1;
+            while (left < right) {
+                int temp = matrix[i][left];
+                matrix[i][left] = matrix[i][right];
+                matrix[i][right] = temp;
+                left++;
+                right--;
+            }
+        }
+    }
+}