람다를 이용해 버블 정렬 구현하기

C# 에는 Array.Sort() 나 List<T>.Sort() 같은 기본 정렬 함수가 제공되지만, 정렬 알고리즘을 직접 구현하면서 람다식이 얼마나 강력한 도구인지 체감해볼 수 있습니다. 

이번 글에서는 람다식을 이용하여 유연한 방식의 버블 정렬을 직접 구현해보겠습니다. 

 

버블 정렬이란?

가장 간단한 정렬 알고리즘 중 하나로, 인접한 두 값을 비교해서 순서를 바꾸는 것을 반복합니다.

int[] arr = { 5, 3, 8, 1 };

for (int i = 0; i < arr.Length - 1; i++)
{
    for (int j = 0; j < arr.Length - 1 - i; j++)
    {
        if (arr[j] > arr[j + 1])
        {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

 

하지만 이 방법은 비교 방식이 고정되어 있어, 내림차순, 사용자 정의 정렬 등은 따로 다시 구현해야 합니다.

 

비교 기준을 람다식으로 만들기

람다식을 활용하면 비교 방식을 외부에서 넘겨줄 수 있습니다.

( 여기서는 (a, b) => a.CompareTo(b) 이 부분에 해당됩니다. )

int[] arr = { 7, 2, 5, 1 };

// 오름차순 정렬
BubbleSort(arr, (a, b) => a.CompareTo(b));
Console.WriteLine(string.Join(", ", arr)); // 출력: 1, 2, 5, 7

 

BubbleSort 함수 구현

static void BubbleSort<T>(T[] data, Func<T, T, int> compare)
{
    int n = data.Length;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (compare(data[j], data[j + 1]) > 0)
            {
                // 튜플 스왑
                (data[j], data[j + 1]) = (data[j + 1], data[j]); 
            }
        }
    }
}

 

•  T[] data 는 정렬할 배열입니다.

•  Func<T, T, int> compare 는 매개 변수 2개 ( T, T ) 를 받아서 int 를 반환하는 대리자입니다.

•  compare 라는 이름의 변수에 (a, b) => a.CompareTo(b) 같은 "람다식(익명 함수)" 을 넘길 수 있는 구조입니다.

 

CompareTo() 란?

CompareTo() 는 C#의 기본 타입들이 구현한 IComparable<T> 인터페이스의 메서드입니다.

public interface IComparable<T>
{
    int CompareTo(T other);
}

 

그리고 다음과 같이 구현되어 있습니다. 

public int CompareTo(int other)
{
    if (this < other) return -1;
    if (this > other) return 1;
    return 0;
}

 

따라서 람다식 (a, b) => a.CompareTo(b) 는 이렇게 작동합니다

•  a < b 라면 -1 을 반환합니다.

•  a == b 라면 0 을 반환합니다. 

•  a > b 라면 +1 을 반환합니다. 

 

조건 판단

if (compare(data[j], data[j + 1]) > 0)
{
    // 튜플 스왑
    (data[j], data[j + 1]) = (data[j + 1], data[j]); 
}

 

•  먼저 compare 를 호출합니다.

•  compare 는 CompareTo() 의 대리자이므로 결과적으로는 CompareTo() 를 호출하게 됩니다. 

•  CompareTo() 는 두 개의 숫자를 비교합니다.

•  이 때, 첫번째 값이 두번째 값보다 크면 +1 을 반환합니다.

•  따라서 양수일 때만 자리를 교환하기 때문에 결국 오름차순 정렬이 되는 구조입니다. 

 

왜 유연한 방식인가?

비교 기준을 넘겨주는 방식이기 때문에, 오름차순뿐 아니라 내림차순 정렬도 아주 쉽게 바꿀 수 있습니다.

int[] arr = { 7, 2, 5, 1 };

// 내림차순 정렬
BubbleSort(arr, (a, b) => b.CompareTo(a));
Console.WriteLine(string.Join(", ", arr)); // 출력: 7, 5, 2, 1

 

•  (a, b) => b.CompareTo(a)
•  기존 오름차순과는 비교 방향을 바꾼 것뿐입니다.

•  이처럼 비교 기준만 바꾸면, 정렬 방식도 유연하게 바꿀 수 있습니다.

 

핵심 요약

•  BubbleSort()는 직접 만든 정렬 함수입니다. (C# 내장 함수가 아님)

•  비교 방식은 외부에서 람다식으로 전달합니다.

•  비교 기준을 바꾸면 정렬 방식도 유연하게 바꿀 수 있습니다.

•  이 패턴을 익히면 Sort(), OrderBy() 등 모든 비교 기반 함수 이해에 도움이 될 것입니다.