Spiral Matrix Problem in Java

Generating a spiral matrix is a common problem in computer science and coding interviews. The challenge involves filling a matrix in a spiral order starting from the top-left corner and moving towards the center. Here, we will discuss two approaches to solve this problem in Java:

Using Iterative Approach
Using Recursive Approach

Using Iterative Approach

It involves iteratively filling the matrix by defining the boundaries (top, bottom, left, right) and adjusting them as we fill in the values in a spiral order.

Initialize Boundaries: Define the initial boundaries for the top, bottom, left, and right sides of the matrix.

Fill Values: Use loops to fill in values while adjusting the boundaries after filling each side (top, right, bottom, left) in a spiral manner.

Adjust Boundaries: After filling each side, adjust the respective boundary to move inward.

File Name: SpiralMatrix.java

 
public class SpiralMatrix {
    public static int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        int value = 1;
        int top = 0, bottom = n - 1;
        int left = 0, right = n - 1;
        while (value <= n * n) {
            // Fill the top row
            for (int i = left; i <= right; i++) {
                matrix[top][i] = value++;
            }
            top++;
            // Fill the right column
            for (int i = top; i <= bottom; i++) {
                matrix[i][right] = value++;
            }
            right--;
            // Fill the bottom row
            for (int i = right; i >= left; i--) {
                matrix[bottom][i] = value++;
            }
            bottom--;
            // Fill the left column
            for (int i = bottom; i >= top; i--) {
                matrix[i][left] = value++;
            }
            left++;
        }
        return matrix;
    }
    public static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int val : row) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        int n = 3;
        int[][] spiralMatrix = generateMatrix(n);
        System.out.println("Spiral Matrix:");
        printMatrix(spiralMatrix);
    }
}   

Output:

 
Spiral Matrix:
1 2 3 
8 9 4 
7 6 5

Time Complexity: O(n²) since each element in the matrix is visited exactly once.

Space Complexity: O(1) for the matrix filling process (excluding the space required for the matrix itself).

Using Recursive Approach

It involves recursively filling the matrix by defining the boundaries (top, bottom, left, right) and adjusting them as we fill in the values in a spiral order.

Initialize Boundaries: Define the initial boundaries for the top, bottom, left, and right sides of the matrix.

Recursive Fill: Use a recursive function to fill in values while adjusting the boundaries after filling each side (top, right, bottom, left) in a spiral manner.

Base Case: Stop the recursion when the boundaries overlap or when the value exceeds n×n.

File Name: SpiralMatrixRecursive.java

 
public class SpiralMatrixRecursive {
    public static void generateMatrix(int[][] matrix, int top, int bottom, int left, int right, int value) {
        if (top > bottom || left > right) {
            return;
        }
        // Fill the top row
        for (int i = left; i <= right; i++) {
            matrix[top][i] = value++;
        }
        top++;
        // Fill the right column
        for (int i = top; i <= bottom; i++) {
            matrix[i][right] = value++;
        }
        right--;
        // Fill the bottom row
        for (int i = right; i >= left; i--) {
            matrix[bottom][i] = value++;
        }
        bottom--;
        // Fill the left column
        for (int i = bottom; i >= top; i--) {
            matrix[i][left] = value++;
        }
        left++;
        // Recur for the next layer
        generateMatrix(matrix, top, bottom, left, right, value);
    }
    public static int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        generateMatrix(matrix, 0, n - 1, 0, n - 1, 1);
        return matrix;
    }
    public static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int val : row) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        int n = 3;
        int[][] spiralMatrix = generateMatrix(n);
        System.out.println("Spiral Matrix:");
        printMatrix(spiralMatrix);
    }
}   

Output:

 
Spiral Matrix:
1 2 3 
8 9 4 
7 6 5

Time Complexity: O(n² ) since each element in the matrix is visited exactly once.

Space Complexity: O(n) due to the recursion stack.

Conclusion

Generating a spiral matrix can be achieved through both iterative and recursive methods, each with its own advantages:

Iterative Approach: This method is straightforward and easy to understand. It involves defining and adjusting boundaries while filling the matrix in a spiral order. It has a time complexity of O(n²) and a space complexity of O(1) for the matrix filling process.
Recursive Approach: This method is more elegant and relies on recursion to fill the matrix layer by layer. While it also has a time complexity of O(n²), it uses additional space for the recursion stack, resulting in a space complexity of O(n).

Both methods are effective for generating spiral matrices, and the choice between them depends on the specific requirements and constraints of your problem, such as readability, ease of implementation, and available memory. Understanding these approaches equips you with versatile techniques to handle matrix generation tasks efficiently.

Next TopicThird-maximum-number-problem-in-java

← prev next →