2.3 선택 정렬(Selection Sort) [디딤돌 자료구조와 알고리즘 with C++]

2.3 선택 정렬(Selection Sort)

이번에는 반복적인 방법으로 해결하는 선택 정렬(Selection Sort) 알고리즘을 살펴볼게요.

 

선택 정렬도 순차 정렬처럼 맨 앞에서부터 제일 작은 원소를 배치하게 만들어 나가는 알고리즘이예요. 차이점은 맨 앞의 원소를 최소값이 있는 위치로 설정한 후에 뒤에 원소들과 비교하여 더 작은 값을 발견하면 최소값의 위치를 바꾸는 거예요. 순차 정렬에서 원소를 교환했던 것과 다릅니다. 선택 정렬은 내부 반복문을 수행한 후에 최소값과 맨 앞의 원소와 교환해요.

선택 정렬(base:배열의 시작 주소, n: 원소 개수, compare:비교 논리)

    반복(i:=0->n)

        min=i

        반복(j:=i+1->n)

            조건(compare(base[min], base[j]) > 0)

                min := j

        교환(base[i],base[min])

예:

2 9 4 1 5 6 8 3 7       (정렬 전, n:9)

2 9 4 1 5 6 8 3 7       (i:0, j:1, min:0)

2 9 4 1 5 6 8 3 7       (i:0, j:2, min:0)

2 9 4 1 5 6 8 3 7       (i:0, j:3, min:3) - min 변경

2 9 4 1 5 6 8 3 7       (i:0, j:4, min:3)

2 9 4 1 5 6 8 3 7       (i:0, j:5, min:3)

2 9 4 1 5 6 8 3 7       (i:0, j:6, min:3)

2 9 4 1 5 6 8 3 7       (i:0, j:7, min:3)

2 9 4 1 5 6 8 3 7       (i:0, j:8, min:3)

1 9 4 2 5 6 8 3 7       (i:0, j:8, min:3) - 교환, 1회전 완료

1 9 4 2 5 6 8 3 7       (i:1, j:2, min:2) - min 변경

1 9 4 2 5 6 8 3 7       (i:1, j:3, min:3) - min 변경

1 9 4 2 5 6 8 3 7       (i:1, j:3, min:4)

1 9 4 2 5 6 8 3 7       (i:1, j:3, min:5)

1 9 4 2 5 6 8 3 7       (i:1, j:3, min:6)

1 9 4 2 5 6 8 3 7       (i:1, j:3, min:7)

1 9 4 2 5 6 8 3 7       (i:1, j:3, min:8)

1 2 4 9 5 6 8 3 7       (i:1, j:3, min:8) - 교환, 2회전 완료

1 2 4 9 5 6 8 3 7       (i:2, j:3, min:2)

1 2 4 9 5 6 8 3 7       (i:2, j:4, min:2)

1 2 4 9 5 6 8 3 7       (i:2, j:5, min:2)

1 2 4 9 5 6 8 3 7       (i:2, j:6, min:2)

1 2 4 9 5 6 8 3 7       (i:2, j:7, min:7) - min 변경

1 2 4 9 5 6 8 3 7       (i:2, j:8, min:7) - min 변경

1 2 3 9 5 6 8 4 7       (i:2, j:8, min:7) - 교환, 3회전 완료

...생략...

 

 

2.3.1 선택 정렬 알고리즘 분석

이번에는 선택 정렬 알고리즘을 분석해 보기로 해요.

선택 정렬(base:배열의 시작 주소, n: 원소 개수, compare:비교 논리)

    반복(i:=0->n)

        min=i

        반복(j:=i+1->n)

            조건(compare(base[min], base[j]) > 0)

                min := j

        교환(base[i],base[min])

 

선택 정렬 알고리즘을 보면 반복문 내부에 반복문이 있는 구조입니다. 먼저 내부의 반복문에서 하는 일이 무엇인지 알아봅시다.

 

선택 정렬 알고리즘의 내부 반복문에서는 j값을 i+1부터 시작하여 n까지 순차적으로 증가하며 작업을 수행하죠. 따라서 루프 변성은 j값이 변하는 것이예요. 그리고 배열의 min번째 요소와 j번째 요소와 비교하여 j번째 요소가 작으면 min을 j로 변경해요. 이처럼 수행하면 배열의 i번째 요소부터 j번째 요소 중에서 제일 작은 값이 있는 위치는 min이죠. 따라서 루프 불변성은 배열의 i번째 요소부터 j번째 요소 중에서 제일 작은 값은 min에 있다는 것이예요.

 

루프 변성인 j값이 n까지 변하는 특징과 루프 불변성인 배열의 i번째 요소부터 j번째 요소 중에서 제일 작은 값은 min에 있다는 것으로 내부 반복문을 수행하면 i번째 요소부터 맨 뒤에 요소 중에 제일 작은 값이 있는 위치는 min이라는 것이예요.

 

이번에는 내부 반복문을 감싸고 있는 외부 반복문을 살펴보아요. i는 0에서 n까지 1씩 증가하고 있어요. 내부 반복문을 수행하면 제일 작은 값이 min에 있죠. 그리고 i번째 요소와 교환을 하고 있어요. 결국 i번째 이후에 요소들은 i보다 큰 값들만 있겠죠. 따라서 i가 변하는 루프 변성과 i이전의 요소들은 정렬 상태이고 i 뒤에 있는 요소들보다 작다는 루프 불변성으로 외부 반복문을 수행하면 정렬할 수 있다는 것을 증명할 수 있어요.

 

이번에는 선택 정렬 알고리즘 성능을 분석합시다.

 

선택 정렬의 내부 반복문의 수행 시간을 S(i)라고 가정할게요. 내부 반복문은 j가 i+1에서 n까지 순차적으로 증가하므로 비교를 n-i번 수행함을 알 수 있어요. 따라서 S(i)= n-i죠.

 

외부 반복문은 i가 0에서 n까지 순차적으로 증가하면서 내부 반복문을 수행하고 교환 1회합니다. 수행 시간을 T(n)이라 가정하면 T(n) = S(0)+1 + S(1)+1 +S(n-2)+1 ... +S(n-1)+1 이죠.

 

따라서 T(n) = S(0)+1 + S(1)+1 +S(n-2)+1 ... +S(n-1)+1 = n+1 + n + n-1 + ...+1

따라서 T(n)= n(n+1)/2 이고 점근식 표기에서 높은 차수의 항만 남고 상수를 버리므로 O(n^2)라고 할 수 있습니다. 선택 정렬도 순차 정렬과 거품 정렬처럼 O(n^2)이네요.

 

하지만 교환하는 시간은 O(n)이라는 차이가 있어요. 물론 전체 성능에 미치는 영향은 아주 작아요.

 

2.3.2 선택 정렬 알고리즘 구현

이번에는 선택 정렬 알고리즘을 구현해 보기로 해요.

선택 정렬(base:배열의 시작 주소, n: 원소 개수, compare:비교 논리)

    반복(i:=0->n)

        min=i

        반복(j:=i+1->n)

            조건(compare(base[min], base[j]) > 0)

                min := j

        교환(base[i],base[min])

 

참고로 2.1.2에서 공통으로 사용할 코드를 이용하세요.

template <typename data, typename compare>

//선택 정렬(base:배열의 시작 주소, n: 원소 개수, compare:비교 논리)

void selection_sort(data *base, size_t n, compare com)

{

    for(size_t i=0; i<n; i++)//반복(i:=0->n)

    {

        size_t min = i;//min=i

        for(size_t j=i+1; j<n; j++) //반복(j:=i+1->n)

        {

            if(com(base[min],base[j])>0)//조건(compare(base[min], base[j]) > 0)

            {

                min = j;//min := j

            }

        }

        swap(base[i],base[min]);//교환(base[i],base[min])

    }

}

 

테스트 코드도 2.1.3에서 작성한 코드에서 sequential_sort 부분을 selection_sort로 변경하세요.

#define MAX_DATA 1000

 

int main()

{

    Member *base[MAX_DATA];

선택 정렬이 잘 동작하는지 10개 원소를 번호 순으로 정렬하여 확인하고 이름 순으로 정렬하여 확인하세요.

    MakeRandomMembers(base,10);

    cout<<"정렬 전"<<endl;

    ViewMembers(base,10);

    selection_sort(base,10,CompareByNum);

    cout<<"번호로 정렬 후"<<endl;

    ViewMembers(base,10);

    selection_sort(base,10,CompareByName);

    cout<<"이름으로 정렬 후"<<endl;

    ViewMembers(base,10);

    RemoveMembers(base,10);

 

그리고 MAX_DATA 개일 때 수행 속도와 MAX_DATA/10 개일 때 수행 속도를 비교해 보세요.

    clock_t st,et;

 

    MakeRandomMembers(base,MAX_DATA);

    cout<<"수행 성능 테스트1 자료 개수:"<<MAX_DATA<<endl;

    st = clock();   

    selection_sort(base,MAX_DATA,CompareByName);   

    et=clock();

    cout<<"수행 속도:"<<et-st<<endl;

    RemoveMembers(base,MAX_DATA);

 

    MakeRandomMembers(base,MAX_DATA/10);

    cout<<"수행 성능 테스트2 자료 개수:"<<MAX_DATA/10<<endl;

    st = clock();

    MakeRandomMembers(base,MAX_DATA/10);

    selection_sort(base,MAX_DATA/10,CompareByName);

    et=clock();

    cout<<"수행 속도:"<<et-st<<endl;

    RemoveMembers(base,MAX_DATA/10);

    return 0;

}

 

다음은 실행 결과예요.

▷실행 결과

정렬 전

0000757147,이름0167851000

0301413356,이름0336971124

0659598368,이름0160567225

0391749387,이름0004890851

0035766290,이름0026239572

0473038164,이름0000597006

0003615544,이름0326051436

0392289610,이름0118341522

0170427798,이름0037215528

0675016433,이름0168544290

번호로 정렬 후

0000757147,이름0167851000

0003615544,이름0326051436

0035766290,이름0026239572

0170427798,이름0037215528

0301413356,이름0336971124

0391749387,이름0004890851

0392289610,이름0118341522

0473038164,이름0000597006

0659598368,이름0160567225

0675016433,이름0168544290

이름으로 정렬 후

0473038164,이름0000597006

0391749387,이름0004890851

0035766290,이름0026239572

0170427798,이름0037215528

0392289610,이름0118341522

0659598368,이름0160567225

0000757147,이름0167851000

0675016433,이름0168544290

0003615544,이름0326051436

0301413356,이름0336971124

수행 성능 테스트1 자료 개수:1000

수행 속도:2995

수행 성능 테스트2 자료 개수:100

수행 속도:31

 

선택 정렬도 결과를 보면 자료 개수가 MAX_DATA일 때 MAX_DATA/10일 때보다 100배 정도 느린 것을 알 수 있습니다. 앞에서 알고리즘 성능을 분석할 때 O(n^2)와 비슷하죠.