Merge Sort(ํฉ๋ณ ์ ๋ ฌ)
Merge Sort์ ๋ํด ์ดํดํด๋ณด๊ธฐ
Merge Sort(ํฉ๋ณ ์ ๋ ฌ)
Merge Sort(ํฉ๋ณ ์ ๋ ฌ)๋?
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ํ๋๋ก,
- ์ ๋ ฅ๊ฐ๋ค์ ๋ถํ ํด์ ์์ ๋ฌธ์ ๋ค๋ก ๋ง๋ค๊ณ (Divide)
- ๊ฐ๊ฐ์ ๋ฌธ์ ๋ค์ ํด๋ฅผ ์ป๊ณ (Conquer)
- ๊ฐ๊ฐ์ ํด๋ค์ ํฉ์ณ์ ์ต์ข ํด๋ฅผ ์ป๋๋ค.(Combine)
Merge Sort(ํฉ๋ณ ์ ๋ ฌ) ๊ณผ์
- ํฉ๋ณ์ ๋ ฌ์ ์ํํจ์๋ฅผ ์ด์ฉํด์ ์ ๋ ฅ๊ฐ๋ค์ ์ ๋ฐ์ผ๋ก ๋ถํ ํ๋ค.
- ์ํํจ์๋ ๊ณ์ ์๊ธฐ์์ ์ ํธ์ถํ๊ณ ๊ฒฐ๊ตญ ๊ฐ๊ฐ์ 1์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋๊น์ง ๋ถํ ๋๋ค.
- ๋ ์ด์ ๋ถํ ํ ์ ์์ผ๋ฏ๋ก ๊ฐ๊ฐ ์ํํจ์๋ค์์ ํฉ๋ณํจ์๋ฅผ ํธ์ถํ๋ฉด์ ์ ๋ ฌ๊ณผ์ (๊ฐ๊ฐ์ ํด๋ค์ ์ป๋๋ค)์ด ์์๋๋ค.
- ๊ฒฐ๊ตญ์ ๋ชจ๋ ํด๋ค์ด ํฉ์ณ์ ธ์ ์ ๋ ฌ๊ณผ์ ์ด ์๋ฃ๋๋ค.
Merge Sort(ํฉ๋ณ ์ ๋ ฌ) ์๊ณ ๋ฆฌ์ฆ
MergeSort(int l, int h){
int m;
if(l >= h) return 0; // ์ํํจ์์ ๋
m = (l + h) / 2;
MergeSort(l, m); //
MergeSort(m+1, h); // ์ํํจ์๋ก ๊ฐ๊ฐ 1/2๋ก ๋ถํ
Merge(l, m, h); // ์ ๋ ฌ ๋ฐ ๊ฐ ํด๋ค์ ํฉ๋ณ ๊ณผ์
}
Merge Sort(ํฉ๋ณ ์ ๋ ฌ) ์๊ฐ ๋ณต์ก๋(Big O)
ํฉ๋ณ์ ๋ ฌ์ ๋ค์๊ณผ ๊ฐ์ ์ํํจ์๋ก ํํํ ์ ์๋ค.
MS(n)
= 0 (if n <= 1)
= 2MS(n/2) + n (if n >= 2)
์ ์ ๋ ๊ฒ ํํํ ์ ์๋ ๊ฑธ๊น?
์ ์ฝ๋์์ ๋ณด๋ฉด MergeSort(l, m)๊ณผ MergeSort(m+1, h)์ด MS(n/2)์ ๋์ผํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด n์ ์ด๋์ ๋ํ๋ ๊ฒ์ผ๊น?
ํฉ๋ณ์ ๋ ฌ ๊ณผ์ ๊ทธ๋ฆผ์ ์๋ Conquer ๋ถ๋ถ์ ์ ์ดํด๋ณด์.
Conquer ๊ณผ์ ์ฆ, Merge(l, m, h)์ ์ ๋ ฌ๊ณผ์ ์์ n๋ฒ์ ์ฐ์ฐ์ด ๋ฐ์ํ๋ค.
๊ฒฐ๊ตญโฆ!
MS(n)
= 2MS(n/2)+n/2 + n
= 2(2MS(n/4) + n/4) + n
= 2^2(MS(n/4)) + n/2 + n
= โฆ
= 2^k * MS(n/2^k) + kn (n/2^k = 1)
= n * log n (k = log n)
์๊ฐ๋ณต์ก๋๋ O(n*log(n))์ด ๋๋ค.
์ง๊ด์ ์ผ๋ก ์ดํดํด๋ณด์๋ฉด ๋ถํ ๊ณผ์ ์์์ ์๊ฐ๋ณต์ก๋๋ O(1)์ด๋ค.
์ฆ, ์ค์ ๋ก๋ ํฉ๋ณ ๊ณผ์ ์์ ์ฐ์ฐ์ ๋๋ถ๋ถ์ด ๋ฐ์ํ๋ค.
๋์ ๋ถํ ๊ณผ์ ์์ ์ ๋ ฅ๊ฐ๋ค์ ์ ๋ฐ์ผ๋ก ๋๋๋ฉด์ ํฉ๋ณ ๊ณผ์ ์ ๋์ด๊ฐ log(n)์ด ๋๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฐ๊ฐ์ ํฉ๋ณ ๊ณผ์ ์์๋ n๋งํผ์ ์ฐ์ฐ์ด ๋ฐ์ํ๋ฏ๋ก ๊ฒฐ๊ตญ n(๊ฐ๋ก) * log n(๋์ด)์ด ๋๋ค.