ํฉ๋ณ ์ ๋ ฌ์ด๋ ๋ฌด์์ผ๊น?
ํฉ๋ณ ์ ๋ ฌ์ ๋ถํ (Divide), ์ ๋ณต(Conquer), ๊ฒฐํฉ(Combine)์ด๋ผ๋ ๊ณผ์ ์ผ๋ก ์งํ๋ฉ๋๋ค. ์์๋ค์ ํ ๋ฒ์ ์ ๋ ฌํ๋ ๊ฒ์ด ์๋ ์์๋ค์ ๋ฐ์ผ๋ก ๋๋๊ณ ์ด๋ฅผ ๋ ๋ฐ์ผ๋ก ๋๋์ด ์ ๋ ฌํ๋ ๊ฒ์ด์ง์.
์ ์ฒด ๊ณผ์ ์ ๋ณด๋ฉด ์๋์ ๊ฐ์ด ํํํ ์ ์์ต๋๋ค.

ํฉ๋ณ ์ ๋ ฌ ์งํ
์์ ์ ์ฒด ์ ๋ ฌ ๊ณผ์ ์ ์กฐ๊ธ ๋ ์์ธํ ๊ฐ ๋จ๊ณ๋ง๋ค ์ดํด๋ด ์๋ค. ์ ๋ ฌ ์์๋ค์ ๋ฐ์ผ๋ก ๋๋์์ ๋ ์ผ์ชฝ ์์ญ์ left, ์ค๋ฅธ์ชฝ ์์ญ์ right๋ก ํ๊ธฐํ๊ณ ๊ฐ๊ฐ์ ์์๊ณผ ๋์ Start, End๋ก ํ๊ธฐํ์ต๋๋ค.





๋ง์ง๋ง ๋น๊ต ๊ณผ์ ์ดํ์ ์ค๋ฅธ์ชฝ ์์ญ์ ์์์ธ rightStart๋ ์ค๋ฅธ์ชฝ์ ๋์ธ rightEnd๋ฅผ ๋์ด์๋ ์์น๊ฐ ๋ฉ๋๋ค. ์ด๋ ๋ ์ด์์ ์ ๋ ฌ์ ์ํ ๋น๊ต๋ ์๋ฏธ๊ฐ ์๋ค๋ ๋ป์ ๋๋ค.
ํฉ๋ณ ์ ๋ ฌ ๊ตฌํ
์ ๊ณผ์ ์ ์์ค ์ฝ๋๋ฅผ ํตํด ์ดํด๋ด ์๋ค.
#include <stdio.h>
#include <stdlib.h>
void Merge(int arr[], int left, int mid, int right)
{
int leftStart = left;
int leftEnd = mid;
int rightStart = mid + 1;
int rightEnd = right;
int index = 0;
// ํฉ๋ณํ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ ๋ฐฐ์ด ๋์ ํ ๋น
int* sortedArr = (int*)malloc(sizeof(int)*(right + 1));
int sortedArrIndex = left;
while ((leftStart <= leftEnd) && (rightStart <= rightEnd)) {
if (arr[leftStart] > arr[rightStart]) {
sortedArr[sortedArrIndex] = arr[rightStart++];
}
else {
sortedArr[sortedArrIndex] = arr[leftStart++];
}
sortedArrIndex++;
}
// ๋ฐฐ์ด์ ์๋ถ๋ถ์ด ๋ชจ๋ ์ ๋ ฌ๋ ๋ฐฐ์ด์ ์ฎ๊ฒจ์ก๋ค๋ฉด
if (leftStart > leftEnd) {
// ๋ฐฐ์ด์ ๋ท๋ถ๋ถ์ ๋จ์ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋๋ก ์ฎ๊ธด๋ค.
for (index = rightStart; index <= rightEnd; index++) {
sortedArr[sortedArrIndex++] = arr[index];
}
}
// ๋ฐฐ์ด์ ๋ท๋ถ๋ถ์ด ๋ชจ๋ ์ ๋ ฌ๋ ๋ฐฐ์ด์ ์ฎ๊ฒจ์ก๋ค๋ฉด
else {
// ๋ฐฐ์ด์ ์๋ถ๋ถ์ ๋จ์ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋๋ก ์ฎ๊ธด๋ค.
for (index = leftStart; index <= leftEnd; index++) {
sortedArr[sortedArrIndex++] = arr[index];
}
}
for (index = left; index <= right; index++)
arr[index] = sortedArr[index];
free(sortedArr);
}
void MergeSort(int arr[], int left, int right)
{
int mid;
// left๊ฐ ๋ ์์ ๊ฒฝ์ฐ๋ ๋ ๋๋ ์ ์๋ ๊ฒฝ์ฐ
if (left < right) {
// ์ค๊ฐ ์ง์ ๊ณ์ฐ
mid = (left + right) / 2;
// left๋ถํฐ mid๊น์ง์ ๋ฐ์ดํฐ ์ ๋ ฌ
MergeSort(arr, left, mid);
// mid+1๋ถํฐ right๊น์ง์ ๋ฐ์ดํฐ ์ ๋ ฌ
MergeSort(arr, mid + 1, right);
// ์ ๋ ฌ๋ ๋ ๋ฐฐ์ด์ ํฉ๋ณํ๊ธฐ
Merge(arr, left, mid, right);
}
}
int main(void)
{
int arr[] = { 6, 3, 9, 1, 2, 7 };
int index = 0;
int arrSize = (sizeof(arr) / sizeof(int));
MergeSort(arr, 0, arrSize-1);
for (index = 0; index < arrSize; index++)
printf("%d ", arr[index]);
return 0;
}
ํฉ๋ณ ์ ๋ ฌ์ ์ฑ๋ฅ์?
์ ๊ณผ์ ์์ < 3, 6, 9 >์ < 1, 2, 7 >์ ํ ๋ฉ์ด๋ฆฌ๋ก ํฉ์น ๋๋ฅผ ์๊ฐํด๋ด ์๋ค.
- 1) 3๊ณผ 1์ ๋น๊ตํ๋ค. ๋น๊ต ์ฐ์ฐ ํ์ 1์ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ์ด๋ํ๋ค.
- 2) 3๊ณผ 2๋ฅผ ๋น๊ตํ๋ค. ๋น๊ต ์ฐ์ฐ ํ์ 2๋ฅผ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ์ด๋ํ๋ค.
- 3) 3๊ณผ 7์ ๋น๊ตํ๋ค. ๋น๊ต ์ฐ์ฐ ํ์ 3์ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ์ด๋ํ๋ค.
- 4) 6๊ณผ 7์ ๋น๊ตํ๋ค. ๋น๊ต ์ฐ์ฐ ํ์ 6์ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ์ด๋ํ๋ค.
- 5) 9์ 7์ ๋น๊ตํ๋ค. ๋น๊ต ์ฐ์ฐ ํ์ 7์ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ์ด๋ํ๋ค.
- ๋ง์ง๋ง์ผ๋ก ๋จ์ < 9 >๋ฅผ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ์ด๋์ํค๊ธฐ ์ํ if - else ๋ฌธ์ ๋น๊ต ์ฐ์ฐ
์ด๋ ๊ฒ, ํ๋์ ์์๊ฐ ๋จ์ ๋๊น์ง ๋น๊ต ์ฐ์ฐ์ด ์งํ๋๋ ๊ฒฝ์ฐ๋ ์ต๋์ ์ฐ์ฐ ํ์์ธ n์ ๊ฐ์ต๋๋ค. ํฉ๋ณ ์ ๋ ฌ์ ์ ๋ ฌํด์ผ ํ ์์ ๊ฐ์ n๊ณผ ํฉ๋ณํ๋ ๊ณผ์ ์ ํ์ k์ ๋ํด์ \(k=\log _{ 2 }{ n }\) ์์ด ์ฑ๋ฆฝ๋ฉ๋๋ค. ์ฆ, ๋น ์ค ํ๊ธฐ๋ฒ์ผ๋ก ํฉ๋ณ ์ ๋ ฌ์ ๋น๊ต ์ฐ์ฐ์ ๋ํ๋ด๋ฉด \(O(n\log _{ 2 }{ n } )\) ์ ๋๋ค.
์์ธํ ๋ณด๋ฉด, ํฉ๋ณ ๊ณผ์ ์์ ์์๋ค์ด ์ด๋๋๋ ์ฐ์ฐ๋ ์์ต๋๋ค. ์ด๋์ด ๋ฐ์ํ๋ ์ด์ ๋ โ์์ ๋ฐฐ์ด์ ์์๋ค์ ํฉ์น๋ ๊ณผ์ โ์์ 1ํ ๋ฐ์ํ๊ณ โ์์ ๋ฐฐ์ด์ ์ ์ฅ๋ ์์๋ค ์ ๋ถ๋ฅผ ์๋ ์์น๋ก ์ด๋ํ๋ ๊ณผ์ โ์์ 1ํ์ฉ ๋ฐ์ํฉ๋๋ค.
์ฆ, ์์ ์ด๋์ผ๋ก ์ธํ ์ฐ์ฐ ํ์๋ ์ต์ , ํ๊ท , ์ต์ ์ ๊ฒฝ์ฐ์ ์๊ด์์ด \(2n\log _{ 2 }{ n }\) ๋ผ๊ณ ๋ณผ ์ ์์ง๋ง ๋น ์ค ํ๊ธฐ๋ฒ์์ ์์์ธ 2๋ ๋ฌด์ํ ์ ์์ผ๋ฏ๋ก ์ต์ข ์ ์ธ ๋น ์ค ํํ์ \(O(n\log _{ 2 }{ n } )\) ๋ผ๊ณ ํ ์ ์์ต๋๋ค.
ํฉ๋ณ ์ ๋ ฌ๊ณผ ํต ์ ๋ ฌ
ํฉ๋ณ ์ ๋ ฌ๊ณผ ํต ์ ๋ ฌ์ ๋น๊ตํ๊ธฐ ์ข์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
ํฉ๋ณ ์ ๋ ฌ์ ๊ฒฝ์ฐ ์์ ๊ทธ๋ฃน์ ์ ๋ ฌํ ํ ๋ ํฐ ๊ทธ๋ฃน์ผ๋ก ํฉ์ณ๋๊ฐ๋ Bottom-Up ๋ฐฉ์์ ๋๋ค. ๋ฐ๋ฉด์ ํต ์ ๋ ฌ์ ํฐ ๊ทธ๋ฃน์์๋ถํฐ ์์ ๊ทธ๋ฃน์ผ๋ก ์ฐ์ฐ์ด ์งํ๋๋ Top-Down ๋ฐฉ์์ด์ง์.
๋ํ, ํต ์ ๋ ฌ์ ์ถ๊ฐ์ ์ธ ์ ์ฅ ๊ณต๊ฐ์ด ํ์ํ์ง ์๊ณ ๋ด๋ถ์ ์ธ ๊ตํ๋ง์ผ๋ก ์ ๋ ฌ์ด ์ํ๋์ง๋ง ํฉ๋ณ ์ ๋ ฌ์ ์ถ๊ฐ์ ์ธ ์ ์ฅ ๊ณต๊ฐ์ ์ฌ์ฉํ์ฌ ์ ๋ ฌ์ ์งํํฉ๋๋ค.
์ฑ๋ฅ ๋ฉด์ผ๋ก๋ ํฉ๋ณ ์ ๋ ฌ์ ๊ฒฝ์ฐ nlogn์ ์ ๋ ฌ ์๊ฐ์ด ๋ณด์ฅ๋๋ฉฐ, ์์น๋ฅผ ๋ค์ ๋ฐฐ์นํ๋ ์๊ฐ์ด ์๊ธฐ ๋๋ฌธ์ ๊ฑฐ์ ๋์ผํ ์ํ ์๊ฐ์ ๊ฐ์ง๋ง ํต ์ ๋ ฌ์ ์ต์ ์ ๊ฒฝ์ฐ ์์๋ค์ ๊ฐ์์ธ n์ด๋ฉฐ, ์ต์ ์ ๊ฒฝ์ฐ n์ ๊ณฑ๊น์ง ๋ ์ ์์ต๋๋ค.
์ด๋ฌํ ์ฐจ์ด์ ์ด ์๋ ๋ ๊ฐ์ ์ ๋ ฌ ๋ฐฉ์์ ๋ชจ๋ ์์ญ์ ๋๋์ด ์ฒ๋ฆฌํ๋ ๋ถํ & ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ๊ธฐ๋ฐํฉ๋๋ค.