C Program To Print Matrix In Spiral Form

In this article, you will learn how to implement a C program to print the elements of a given matrix in a spiral order. This technique is fundamental for various data processing tasks and algorithmic challenges.

Problem Statement

The challenge is to traverse a 2D array, or matrix, and print all its elements following a clockwise spiral path. This means starting from the top-left corner, moving right across the top row, then down the rightmost column, then left across the bottom row, then up the leftmost column, and continuing this inward spiral until all elements are visited. This problem is common in algorithmic interviews and can be applied in areas requiring specific data traversal patterns.

Example

Consider a 3x4 matrix:

1  2  3  4
5  6  7  8
9 10 11 12

The spiral output should be: 1 2 3 4 8 12 11 10 9 5 6 7

Background & Knowledge Prerequisites

To understand and implement this solution, readers should have a basic understanding of:

• C Programming Basics: Variables, data types, loops (for, while), conditional statements (if-else).
• Arrays in C: Specifically, 2D arrays (matrices) and how to declare, initialize, and access their elements.
• Functions: Basic concept of functions, though a single main function can suffice for demonstration.

No specific libraries beyond stdio.h for input/output are required.

Use Cases or Case Studies

Printing a matrix in spiral form is not just an academic exercise; it has practical applications:

• Image Processing: In certain image processing algorithms, pixels might need to be traversed in a spiral pattern, for example, when applying filters or analyzing regions of interest.
• Game Development: For pathfinding in grid-based games, defining enemy patrols, or loading map segments in a specific order.
• Data Compression: Some data compression techniques might leverage spiral traversal to group related data points.
• Puzzle Solving: It's a common pattern in various grid-based puzzles and competitive programming problems.
• Memory Access Optimization: In specific hardware architectures, accessing memory in a spiral might be more cache-friendly for certain data layouts.

Solution Approaches

While several conceptual ways exist, the most robust and commonly used approach involves tracking and shrinking boundaries.

Boundary Shrinking Method

This approach iteratively prints elements from the outer layer of the matrix inwards, adjusting four boundary pointers (top, bottom, left, right) after each pass.

One-line Summary

Print elements by traversing the current outer layer (top row, right column, bottom row, left column) and then shrinking the boundaries inwards until all elements are processed.

Code Example

// Print Matrix in Spiral Form
#include <stdio.h>

void printMatrixInSpiral(int rows, int cols, int matrix[rows][cols]) {
    int top = 0;        // Top row index
    int bottom = rows - 1; // Bottom row index
    int left = 0;       // Left column index
    int right = cols - 1; // Right column index

    // Loop until all elements are processed
    while (top <= bottom && left <= right) {
        // Step 1: Print the top row from left to right
        for (int i = left; i <= right; i++) {
            printf("%d ", matrix[top][i]);
        }
        top++; // Move top boundary down

        // Step 2: Print the rightmost column from top to bottom
        for (int i = top; i <= bottom; i++) {
            printf("%d ", matrix[i][right]);
        }
        right--; // Move right boundary left

        // Step 3: Print the bottom row from right to left, if bottom boundary is still valid
        if (top <= bottom) { // Check needed for single row or already processed row
            for (int i = right; i >= left; i--) {
                printf("%d ", matrix[bottom][i]);
            }
            bottom--; // Move bottom boundary up
        }

        // Step 4: Print the leftmost column from bottom to top, if left boundary is still valid
        if (left <= right) { // Check needed for single column or already processed column
            for (int i = bottom; i >= top; i--) {
                printf("%d ", matrix[i][left]);
            }
            left++; // Move left boundary right
        }
    }
    printf("\\n"); // Newline after printing
}

int main() {
    // Example 1: 3x4 Matrix
    int matrix1[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    printf("Matrix 1 (3x4) in spiral form: ");
    printMatrixInSpiral(3, 4, matrix1);

    // Example 2: 4x4 Matrix
    int matrix2[4][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}
    };
    printf("Matrix 2 (4x4) in spiral form: ");
    printMatrixInSpiral(4, 4, matrix2);

    // Example 3: Single row matrix
    int matrix3[1][5] = {
        {10, 20, 30, 40, 50}
    };
    printf("Matrix 3 (1x5) in spiral form: ");
    printMatrixInSpiral(1, 5, matrix3);

    // Example 4: Single column matrix
    int matrix4[5][1] = {
        {10}, {20}, {30}, {40}, {50}
    };
    printf("Matrix 4 (5x1) in spiral form: ");
    printMatrixInSpiral(5, 1, matrix4);

    return 0;
}

Run

Sample Output

Matrix 1 (3x4) in spiral form: 1 2 3 4 8 12 11 10 9 5 6 7 
Matrix 2 (4x4) in spiral form: 1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10 
Matrix 3 (1x5) in spiral form: 10 20 30 40 50 
Matrix 4 (5x1) in spiral form: 10 20 30 40 50

Stepwise Explanation

1. Initialize Pointers: Four integer variables (top, bottom, left, right) are initialized to represent the current boundaries of the sub-matrix being processed. top and left start at 0, while bottom and right are rows - 1 and cols - 1 respectively.
2. Main Loop: A while loop continues as long as top <= bottom and left <= right. This condition ensures that there are still elements within the current boundaries to process.
3. Traverse Top Row: The loop first prints elements from matrix[top][left] to matrix[top][right]. After this, top is incremented, effectively moving the top boundary down by one row.
4. Traverse Right Column: Next, it prints elements from matrix[top][right] to matrix[bottom][right]. right is then decremented, moving the right boundary left by one column.
5. Traverse Bottom Row (Conditional): Before traversing the bottom row, a check if (top <= bottom) is crucial. This handles cases where only a single row remains or where the top pointer might have crossed bottom due to previous traversals (e.g., in a single-row matrix). If valid, it prints elements from matrix[bottom][right] to matrix[bottom][left] in reverse order. bottom is then decremented.
6. Traverse Left Column (Conditional): Similarly, before traversing the left column, if (left <= right) is checked. If valid, it prints elements from matrix[bottom][left] to matrix[top][left] in reverse order. left is then incremented.
7. Loop Continuation: The loop repeats, processing the next inner layer of the matrix. The boundaries continuously shrink until top crosses bottom or left crosses right, indicating all elements have been visited.

Conclusion

The boundary shrinking method provides an efficient and clear way to print a matrix in spiral form. By systematically updating four boundary pointers, we can process each layer of the matrix and cover all elements exactly once. This technique is valuable for understanding 2D array manipulations and is a classic problem in computer science.

Summary

• Spiral traversal involves visiting matrix elements layer by layer, starting from the outermost.
• The boundary shrinking method uses top, bottom, left, and right pointers to define the current processing area.
• The algorithm proceeds in four steps: traverse top row, right column, bottom row (reverse), and left column (reverse).
• Boundary pointers are adjusted after each step, shrinking the effective matrix.
• Conditional checks (if (top <= bottom) and if (left <= right)) are essential to prevent invalid access and handle single-row/column matrices correctly.
• This technique is widely applicable in image processing, game development, and algorithmic problem-solving.