JavaScript๋ก ์์๋ณด๋ ๋ณํฉ ์ ๋ ฌ(Merge Sort)๊ณผ ์์ ์ฝ๋
์๊ฐ
๋ณํฉ ์ ๋ ฌ(Merge Sort)์ ๋ํ์ ์ธ ๋ถํ ์ ๋ณต(Divede and Conquer) ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ก, ๋ฆฌ์คํธ๋ฅผ ๋ฐ์ผ๋ก ๋๋ ๋ค ๊ฐ๊ฐ์ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌํ๊ณ , ์ ๋ ฌ๋ ๋ ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ํฉ์ณ์ ์ ๋ ฌ๋ ํ๋์ ๋ฆฌ์คํธ๋ฅผ ๋ง๋๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
์๋ ๊ฐ๋ ๐ก
๋ณํฉ ์ ๋ ฌ์ ์ผ๋ฐ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ ์ธ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
- ๋ถํ (Divide): ์ ๋ ฅ ๋ฆฌ์คํธ๋ฅผ ๊ฐ์ ํฌ๊ธฐ์ ๋ ๊ฐ์ ๋ถ๋ถ ๋ฆฌ์คํธ๋ก ๋ถํ ํฉ๋๋ค. ์ด๋ ๋ถํ ์ ๋ฆฌ์คํธ์ ์ค๊ฐ ์ง์ ์์ ์ํ๋ฉ๋๋ค.
- ์ ๋ณต(Conquer): ๊ฐ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ณํฉ์ ๋ ฌ์ ์ด์ฉํด ์ ๋ ฌํฉ๋๋ค. ์ด ๊ณผ์ ์ ์ ๋ ฅ ๋ฆฌ์คํธ์ ํฌ๊ธฐ๊ฐ ์ถฉ๋ถํ ์์์ง ๋๊น์ง ๋ฐ๋ณต๋ฉ๋๋ค.
- ๋ณํฉ(Merge): ์ ๋ ฌ๋ ๋ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ํ๋์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ก ๋ณํฉํฉ๋๋ค.
- 0๊ฐ ์์, 1๊ฐ ์์ ๋ฐฐ์ด์ด ์ด๋ฏธ ์ ๋ ฌ๋์ด ์๋ค๋ ์ ์ ํ์ฉํฉ๋๋ค.
- ๋ฐฐ์ด์ ๋ ์์ ๋ฐฐ์ธ๋ ค ๋๋๋ ๋ฐฉ์์ ๋๋ค.
- ๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ์๋ ค์ง ๋ฐฉ์์ด๊ณ , ๋ ํฐ ๋ฐฐ์ด์ ๋๋๊ณ , ๋ ์์ ํ์ ๋ฐฐ์ด๋ก ์ ๋ ฌํฉ๋๋ค.
- ๋ฐฐ์ด์ ์์๊ฐ 0 ๋๋ 1๊ฐ๊ฐ ๋ ๋๊น์ง ๋ฐ๋ณตํฉ๋๋ค.
- ๊ณ์ ๋ถํ ํ ๋ค์ ๋ค์ ๋ณํฉ์ํต๋๋ค.
๋ฐฐ์ด์ ๋ณํฉํ๋ ์ฝ๋
function merge(arr1, arr2) {
const results = [];
let i = 0;
let j = 0;
while (i < arr1.length && j < arr2.length) {
if (arr2[j] > arr1[i]) {
results.push(arr1[i]);
i++;
} else {
results.push(arr2[j]);
j++;
}
}
while (i < arr1.length) {
results.push(arr1[i]);
i++;
}
while (j < arr2.length) {
results.push(arr2[j]);
j++;
}
return results;
}
- ์ ๋ ฅ ๋ ๊ฐ๋ฅผ ์ทจํ๋ ํจ์๋ฅผ ์ ์ํ์ฌ ๋น ๋ฐฐ์ด์ ๋ง๋ค๊ณ , ๋ง์ง๋ง์ ๋ฐํํ ๋น ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค.
- ๊ฐ ์ ๋ ฅ ๋ฐฐ์ด์์ ๊ฐ์ฅ ์์ ๊ฐ(์ฒ์)๋ถํฐ ์์ํฉ๋๋ค.
- i์ j ๋ ๊ฐ์ ์นด์ดํฐ๊ฐ ์์ต๋๋ค. ์ด ์นด์ดํฐ๋ค์ 0๋ถํฐ ์์ํฉ๋๋ค.
- ์์ง ์ดํด๋ณด์ง ์์ ๊ฐ์ด ์๋ค๋ฉด, ์ฆ i์ j๊ฐ ๊ฐ๊ฐ์ ๋ฐฐ์ด ๋์ ๋๋ฌํ์ง ์์๋ค๋ฉด
- ์ฒซ ๋ฒ์งธ ๋ฐฐ์ด์ ๊ฐ์ผ๋ก ์ฒซ ๋ฒ์งธ ํญ๋ชฉ์ ์ทจํ ๋ค์ ๋ ๋ฒ์งธ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ํญ๋ชฉ ๊ฐ๊ณผ ๋น๊ตํฉ๋๋ค.
- ์ฒซ ๋ฒ์งธ ํญ๋ชฉ์ด ๋ ์๋ค๋ฉด results ๋ฐฐ์ด์ ๋ฃ๊ณ ๋ค์ ์ฒซ ๋ฒ์งธ ๋ฐฐ์ด์ ๋ค์ ํญ๋ชฉ์ผ๋ก ๋์ด๊ฐ๋๋ค.
- ๋ฐ๋๋ก ์ฒซ ๋ฒ์งธ ๋ฐฐ์ด์ ์๋ ํญ๋ชฉ์ด ๋ ํฌ๋ค๋ฉด ๋ ๋ฒ์งธ ๋ฐฐ์ด์ ๊ฐ์ ์ทจํ์ฌ results ๋ฐฐ์ด์ ๋ฃ์ ๋ค์ ๋ ๋ฒ์งธ ๋ฐฐ์ด์ ๋ค์ ๊ฐ์ผ๋ก ๋์ด๊ฐ๋๋ค
- ๋ฐฐ์ด ํ๋๋ฅผ ์๋ฃํ ๋ค์์๋ ๋ค๋ฅธ ๋ฐฐ์ด์ ๋จ์ ๊ฐ์ ๋ชจ๋ ๋ฃ์ต๋๋ค.
๋ณํฉ์ ๋ ฌ ๊ตฌํ ์ฝ๋
function mergeSort(arr) {
if (arr.length <= 1) return arr;
const mid = Math.floor(arr.length / 2);
const left = mergeSort(arr.slice(0, mid));
const right = mergeSort(arr.slice(mid));
return merge(left, right);
}
console.log(mergeSort([10, 24, 76, 73])); // [10, 24, 73, 76]
- ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 1๋๋ 0์ด ๋ ๋๊น์ง mergeSort ํจ์๋ฅผ ํธ์ถํฉ๋๋ค.
- ๋ฐฐ์ด์ ์ ๋ฐ์ ์๋ฅด๊ธฐ ์ํด์ mid๋ผ๋ ๋ณ์์ ๋ฐฐ์ด ๊ธธ์ด / 2์ ๋ด๋ฆผ ๊ฐ์ ์ ์ฅํฉ๋๋ค.
- ์ผ์ชฝ ์ ๋ฐ๊ณผ ์ค๋ฅธ์ชฝ ์ ๋ฐ์ slice ๋ฉ์๋๋ฅผ ํตํด์ ๋๋ ์คฌ๋๋ฐ, ์ด๋ค์๊ฒ mergeSort๋ฅผ ํธ์ถํด ์ค๋๋ค.
์๊ฐ ๋ณต์ก๋
์ต๊ณ | ํ๊ท | ์ต์ | ๊ณต๊ฐ ๋ณต์ก๋ |
O(n log n) | O(n log n) | O(n log n) | O(n) |
๊ณ์ ๋๋๊ณ ๋๋ ๋ค์ ํฉ์น๊ณ ๋ ํฉ์น ๋ฟ์ด๊ธฐ ๋๋ฌธ์ ๋ณํฉ ์ ๋ ฌ์์๋ ์์ธ ์ผ์ด์ค๊ฐ ์์ต๋๋ค.
O(log n)์ ๋ง์ฝ 32๊ฐ์ ์์๊ฐ ์๋ค๋ฉด 2x2x2x2x2๋ผ๋ ์๋ฏธ์ธ๋ฐ, n log n์ ๊ฐ ๋ถํ ๋ง๋ค, ๋ณํฉํ ๋ O(n)๋ฒ ๋น๊ตํฉ๋๋ค.
n์ ๊ธธ์ด๊ฐ ๋์ด๋๋ค๋ฉด, ๋ณํฉ ์ ๋ ฌ์ด ์๋ ๋ณํฉ ์๊ณ ๋ฆฌ์ฆ ์์ฒด๋ O(n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๊ฒ ๋๋๋ฐ ๊ทธ๋์ ์ข
ํฉ์ ์ผ๋ก ๋ณด๋ฉด ๋ณํฉ ์ ๋ ฌ์ Big O๋ O(n log n)์ด ๋ฉ๋๋ค.
์ ๋ฆฌํ์๋ฉด log n์ n์ฆ๊ฐ์ ๋ฐ๋ฅด๋ ๋ถํ ์์
๋๋ค.
n์ ๋ฐ๋ผ ๋ถํ ํ ํ์๋ฅผ ๋งํ๊ณ , ๋ฐฐ์ด์ด ๋์ด๋๋ฉด log n ๋น์จ๋ก ๋์ด๋๋ค.
๋ณํฉ์ ์ค์ ๋ก ์ํํ๋ ค๋ฉด O(n) ๋น๊ต๊ฐ ํ์ํ๊ณ ๊ฒฐ๊ณผ์ ์ผ๋ก๋ ์ด O(n log n)์ด ๋ฉ๋๋ค.