나선형 행렬(Spiral Matrix) 따라하기

6/15/2025
10 minutes to read

// A spiral matrix is a square matrix where elements are filled in a spiral order,
// typically starting from the top-left corner and proceeding clockwise.

개요

나선형 행렬(Spiral Matrix) 은 2차원 배열에 값을 일정한 방향으로 회전하며 채우는 알고리즘 패턴입니다. 한국 교육에서는 흔히 달팽이 배열(Snail Array) 이라고도 부르며, 정보처리기사, 프로그래밍 입문자, 코딩 테스트에서 자주 등장합니다.

이 문서에서는 Spiral Matrix를 생성하는 방법을 단계별로 설명하고, 구현 및 실행 결과를 함께 확인해 봅니다.

용어 정리: 달팽이 배열 vs Spiral Matrix

용어	설명
달팽이 배열 (Snail Array)	한국 교육 과정이나 시험에서 사용되는 비공식 명칭
Spiral Matrix	전 세계적으로 통용되는 정식 알고리즘 명칭
나선형 행렬	Spiral Matrix의 수학적 번역 표현, 이산 수학 및 행렬 이론에서 사용됨

문제 예시

N × N 크기의 정사각형 배열을 1부터 N²까지 시계방향으로 나선형으로 채우시오.

예: N = 4일 때 결과는 다음과 같습니다.

 1  2  3  4
12 13 14  5
11 16 15  6
10  9  8  7

알고리즘 개요

Spiral Matrix 알고리즘은 다음 네 방향을 순서대로 반복하면서 배열을 채웁니다.

→ 오른쪽
↓ 아래쪽
← 왼쪽
↑ 위쪽

이때 배열의 가장자리에서 시작하여 안쪽으로 회전하며 값을 채우고, 매 반복마다 경계값 (top, bottom, left, right)을 조정합니다.

구현 단계

1. 변수 선언 및 초기화

N: 배열의 크기
arr[N][N]: 값을 저장할 2차원 배열
num: 현재 채울 숫자 (1부터 시작)
top, bottom, left, right: 경계값

2. 방향 순서대로 배열 채우기

오른쪽(→): arr[top][left ~ right] 채운 후 top++
아래쪽(↓): arr[top ~ bottom][right] 채운 후 right--
왼쪽(←): arr[bottom][right ~ left] 채운 후 bottom--
위쪽(↑): arr[bottom ~ top][left] 채운 후 left++

이 과정을 top <= bottom && left <= right 조건이 유지되는 동안 반복합니다. 물론입니다. 아래는 Spiral Matrix 결과: 출력 라인을 제거한 버전이며, DocFX 탭 형식은 그대로 유지하면서 C, C#, Java, Python 코드에 동일한 주석도 유지했습니다.

전체 코드 예제

spiral_matrix.c

#include <stdio.h>

#define N 5  // 배열 크기를 컴파일 타임 상수로 정의

int main(void)
{
    // 나선형으로 값을 채울 2차원 배열
    int arr[N][N];

    // 현재 채워야 할 숫자
    int num = 1;

    // 위쪽 경계
    int top = 0;

    // 아래쪽 경계
    int bottom = N - 1;

    // 왼쪽 경계
    int left = 0;

    // 오른쪽 경계
    int right = N - 1;

    // 나선형으로 배열 채우기
    while (top <= bottom && left <= right) // 나선형으로 덮지 않은 영역이 남아 있는 동안 반복
    {
        // → 오른쪽으로 채우기
        for (int i = left; i <= right; i++)
        {
            arr[top][i] = num++;
        }
        top++;

        // ↓ 아래쪽으로 채우기
        for (int i = top; i <= bottom; i++)
        {
            arr[i][right] = num++;
        }
        right--;

        // ← 왼쪽으로 채우기
        for (int i = right; i >= left; i--)
        {
            arr[bottom][i] = num++;
        }
        bottom--;

        // ↑ 위쪽으로 채우기
        for (int i = bottom; i >= top; i--)
        {
            arr[i][left] = num++;
        }
        left++;
    }

    // 결과 출력
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            printf("%3d", arr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

  1  2  3  4  5
 16 17 18 19  6
 15 24 25 20  7
 14 23 22 21  8
 13 12 11 10  9

SpiralMatrix.cs

using System;

class SpiralMatrix
{
    static void Main()
    {
        const int N = 5;

        // 나선형으로 값을 채울 2차원 배열
        int[,] arr = new int[N, N];

        // 현재 채워야 할 숫자
        int num = 1;

        // 위쪽, 아래쪽, 왼쪽, 오른쪽 경계
        int top = 0;
        int bottom = N - 1;
        int left = 0;
        int right = N - 1;

        // 나선형으로 배열 채우기
        while (top <= bottom && left <= right) // 나선형으로 덮지 않은 영역이 남아 있는 동안 반복
        {
            // → 오른쪽으로 채우기
            for (int i = left; i <= right; i++)
            {
                arr[top, i] = num++;
            }
            top++;

            // ↓ 아래쪽으로 채우기
            for (int i = top; i <= bottom; i++)
            {
                arr[i, right] = num++;
            }
            right--;

            // ← 왼쪽으로 채우기
            for (int i = right; i >= left; i--)
            {
                arr[bottom, i] = num++;
            }
            bottom--;

            // ↑ 위쪽으로 채우기
            for (int i = bottom; i >= top; i--)
            {
                arr[i, left] = num++;
            }
            left++;
        }

        // 결과 출력
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                Console.Write("{0,3}", arr[i, j]);
            }
            Console.WriteLine();
        }
    }
}

  1  2  3  4  5
 16 17 18 19  6
 15 24 25 20  7
 14 23 22 21  8
 13 12 11 10  9

SpiralMatrix.java

public class SpiralMatrix
{
    public static void main(String[] args)
    {
        final int N = 5;

        // 나선형으로 값을 채울 2차원 배열
        int[][] arr = new int[N][N];

        // 현재 채워야 할 숫자
        int num = 1;

        // 위쪽, 아래쪽, 왼쪽, 오른쪽 경계
        int top = 0;
        int bottom = N - 1;
        int left = 0;
        int right = N - 1;

        // 나선형으로 배열 채우기
        while (top <= bottom && left <= right) // 나선형으로 덮지 않은 영역이 남아 있는 동안 반복
        {
            // → 오른쪽으로 채우기
            for (int i = left; i <= right; i++)
            {
                arr[top][i] = num++;
            }
            top++;

            // ↓ 아래쪽으로 채우기
            for (int i = top; i <= bottom; i++)
            {
                arr[i][right] = num++;
            }
            right--;

            // ← 왼쪽으로 채우기
            for (int i = right; i >= left; i--)
            {
                arr[bottom][i] = num++;
            }
            bottom--;

            // ↑ 위쪽으로 채우기
            for (int i = bottom; i >= top; i--)
            {
                arr[i][left] = num++;
            }
            left++;
        }

        // 결과 출력
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                System.out.printf("%3d", arr[i][j]);
            }
            System.out.println();
        }
    }
}

  1  2  3  4  5
 16 17 18 19  6
 15 24 25 20  7
 14 23 22 21  8
 13 12 11 10  9

spiral_matrix.py

N = 5

# 나선형으로 값을 채울 2차원 배열 초기화
arr = [[0] * N for _ in range(N)]

num = 1

# 위쪽, 아래쪽, 왼쪽, 오른쪽 경계
top, bottom = 0, N - 1
left, right = 0, N - 1

# 나선형으로 배열 채우기
while top <= bottom and left <= right:  # 나선형으로 덮지 않은 영역이 남아 있는 동안 반복

    # → 오른쪽으로 채우기
    for i in range(left, right + 1):
        arr[top][i] = num
        num += 1
    top += 1

    # ↓ 아래쪽으로 채우기
    for i in range(top, bottom + 1):
        arr[i][right] = num
        num += 1
    right -= 1

    # ← 왼쪽으로 채우기
    for i in range(right, left - 1, -1):
        arr[bottom][i] = num
        num += 1
    bottom -= 1

    # ↑ 위쪽으로 채우기
    for i in range(bottom, top - 1, -1):
        arr[i][left] = num
        num += 1
    left += 1

# 결과 출력
for row in arr:
    print(" ".join(f"{n:3}" for n in row))

  1  2  3  4  5
 16 17 18 19  6
 15 24 25 20  7
 14 23 22 21  8
 13 12 11 10  9

알고리즘 특징 및 정형성

이 알고리즘은 다음과 같은 정형화된 패턴을 따릅니다:

특징
방향 순회: 오른쪽 → 아래 → 왼쪽 → 위 반복
경계값(`top`, `bottom`, `left`, `right`) 조절
while 루프 내에서 각 방향을 순차적으로 처리
1부터 N²까지의 값을 순차적으로 채움

이 구조는 반시계방향 배열, 중앙에서 시작하는 배열, 비정방형 배열 등으로도 손쉽게 확장이 가능합니다.

활용 사례

분야	설명
정보처리기사	반복문과 2차원 배열 제어 문제로 자주 출제됨
코딩 테스트	나선형 순회 또는 특수 패턴 출력 문제 (예: LeetCode, 프로그래머스 등)
프로그래밍 학습용 예제	배열 인덱스 제어, 패턴 출력, 조건문·반복문 실습용으로 효과적

요약

나선형 행렬(Spiral Matrix) 은 시계 방향으로 값을 채우는 배열 알고리즘입니다.
경계값 조절을 통해 반복적으로 순회하면서 배열을 채우는 구조로, 자료구조 + 시뮬레이션 알고리즘의 핵심 패턴을 학습할 수 있습니다.
정보처리기사, 코딩 테스트, 대학 수업 등 다양한 교육 및 실무 상황에서 자주 응용되므로 반드시 익혀두는 것이 좋습니다.

추천 자료: ASP.NET Core 인증 및 권한 부여

추천 자료: .NET Blazor에 대해 알아보시겠어요? .NET Blazor 알아보기를 확인해보세요!