๐ ๋ณํฉ์ ๋ ฌ
๋ณํฉ์ ๋ ฌ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ ๋ฆฌ์คํธ A, B์ ๋ณํฉ์ผ๋ก ์ ๋ ฌํด๋๊ฐ๋ ๋ฐฉ์์ด๋ค. ๋ณํฉ์ ๋ ฌ์ ๋ํ์ ์ธ ๋ถํ ์ ๋ณต๊ธฐ๋ฒ(Divide-and-Conquer) ์ค ํ๋๋ก ๋ฌธ์ ๋ฅผ ์์ ๋จ์๋ก ์ชผ๊ฐ์ ํ์ด๋๊ฐ๋ ๋ฐฉ์์ด๋ค. ๋ถํ ์ ๋ณต๊ธฐ๋ฒ์ ์ฌ์ฉํ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์๋ ๋ณํฉ์ ๋ ฌ, ํต์ ๋ ฌ์ด ์๋ค.
๋ณํฉ์ ๋ ฌ์์ ์ค์ํ ์์ด๋์ด๋
์ฃผ์ด์ง ๋ฆฌ์คํธ๋ฅผ ์ผ๋จ ๋ฐ์ผ๋ก ์๋ฅด๊ณ ๋์ค์ ํฉ์น์๋ ๊ฒ์ด๋ค. ๋ค์๊ณผ ๊ฐ์ ๋ ๊ฐ์ง ๋จ๊ณ๋ก ์๊ฐํด๋ณผ ์ ์๋ค.
1) ๋ถํ ์ ๋ณต๊ธฐ๋ฒ์ ๋ง๊ฒ ๋ณํฉ์ ๋ ฌ๋ ์ฃผ์ด์ง ๋ฆฌ์คํธ๋ฅผ ์์ 1์ธ ๋ฆฌ์คํธ ์ฌ๋ฌ ๊ฐ๋ก ์ชผ๊ฐ์ง๋๋ก ์๋ฅธ๋ค. ์๋ฅด๋ ๊ธฐ์ค์ ์ด์ง๋ถํ ์ด๋ค.
2) ๋ชจ๋ ๋ค ๋ถํ ํ์ฌ ์ฃผ์ด์ง ์๋ณธ ๋ฆฌ์คํธ์ ๊ธธ์ด N๋งํผ์ ๊ฐ ์์ ๋ฆฌ์คํธ๊ฐ ์์ฑ๋๋ค. ์ด ๊ฐ ์์๋ฅผ ํ๋์ ๋ฆฌ์คํธ๋ก ๊ฐ์ฃผํ์ฌ ๋ ๊ฐ์ฉ ๋ณํฉํด ๋๊ฐ๋ฉฐ ์์ฐจ์ ์ผ๋ก ์ ๋ ฌํ๋ค.
mergesort
๋จผ์ ์ฃผ์ด์ง ๋ฆฌ์คํธ๋ฅผ ํฌ๊ธฐ 1์ ์์ ๋ฆฌ์คํธ๋ก ๋ชจ๋ ๋ถํ ํด์ผ ํ๋ค. ์ฃผ์ด์ง ๋ฆฌ์คํธ๊ฐ ๋ค์ด์ค๋ฉด ๋ถํ ์ง์ (middle)์ ๊ณ์ฐํด left, right 2๊ฐ๋ก ๋๋์ด ๋ฆฌ์คํธ๋ฅผ ๋ค์ ๊ตฌ์ฑํ๋ค. ์ด ๋ฆฌ์คํธ๋ฅผ ๊ฐ๊ฐ ์ ๋ ฌํด์ ๋ค์ ํฉ์ณ์ผ ํ๋๋ฐ, ์ด๋ ํ์ํ ๊ฒ์ด ์ ๋ ฌํ๋ฉด์ ๋ณํฉํ๋ ํจ์(merge)์ด๋ค.
mergesort ํจ์๋ก split์ด ๋๋ ๋๊น์ง splitํ๋ฉด ๊ฐ ๋ฆฌ์คํธ๋ ์์๋ฅผ ํ๋ ๊ฐ์ง๋ฏ๋ก ๋ชจ๋ ์ ๋ ฌ๋ ์ํ๋ผ๊ณ ๋ณผ ์ ์๋ค. ์ด๋ ๋ฆฌ์คํธ๋ฅผ 2๊ฐ์ฉ ๋ฌถ์ด ํฉ์ณ ์ ๋ ฌํด ์๋กญ๊ฒ ์ ๋ ฌ๋ ํฌ๊ธฐ 2์ง๋ฆฌ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ ๋ค. ์ฆ, ์๋ ๊ทธ๋ฆผ์์ [6], [5] ๋ฆฌ์คํธ ๋ ๊ฐ๋ฅผ [5, 6] ์ผ๋ก ์ ๋ ฌ๋ ์ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ ๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋จ์ ๋ฆฌ์คํธ์ ๋ํด 2๊ฐ์ฉ ๋ฌถ์ด ๋ณํฉํ๋ฉฐ ์๋ก์ด ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด ๋๊ฐ ๊ฒฐ๊ณผ [5, 6], [2, 7], [3, 1], [4, 8] ์ ๊ฒฐ๊ณผ๋ฅผ ์ป๋๋ค.
vector<int> mergesort(vector<int> L) {
if (L.size() == 1) {
return L;
}
// ๋ถํ ์ง์ (mid) ์ ํด์ left, right๋ก split
int mid = L.size() / 2;
vector<int> left, right;
for (int i = 0; i < mid; i++) {
left.push_back(L[i]);
}
for (int i = mid; i < L.size(); i++) {
right.push_back(L[i]);
}
// left์ right vector ๊ฐ๊ฐ ์ ๋ ฌํด์ ๋ค์ ํฉ์น๊ธฐ
vector<int> result = merge(mergesort(left), mergesort(right));
return result;
}
์ ๊ณต์ผ๋ก ๋ค์๋ ์๊ณ ๋ฆฌ์ฆ ใ ใ ใ ๊ต์๋์ ๊ฐ์์๋ฃ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฐธ๊ณ ํด ๊ตฌํํ์ต๋๋ค. ๊ต์๋์ ์ฒ์ฌ์ ๋ฐ์์ ๊ฐํํ๋ฉฐ ์ฐธ๊ณ ํ์ต๋๋ค.. ์ถํ ๋ฌธ์ ๊ฐ ๋๋ค๋ฉด ์ญ์ ํ ๊ฒ์..
merge
์ด๋ ๋ณํฉํ ๋ ๋ฆฌ์คํธ๋ฅผ ๊ฐ๊ฐ A, B (๋๋ Left, Right) ๊ฐ ํจ์๋ก ๋ค์ด์ค๋ฉด
๊ฐ๋จํ๊ฒ A๊ฐ ๋น์ด์๋ค๋ฉด B๋ฅผ, B๊ฐ ๋น์ด์๋ค๋ฉด A๋ฅผ ๋ฆฌํดํ๋ฉด ๋๋ค. ๊ทธ๋ ์ง ์๊ณ A์ B์ ๋ ๋ค ์์๊ฐ ๋ค์ด์๋ค๋ฉด ์ฒซ๋ฒ์งธ ์์(A[0], B[0])๋ฅผ ๋น๊ตํด ๋ ์์ ๊ฐ์ ์๋ก์ด ์ ๋ ฌ๋ฆฌ์คํธ์ ์ฒซ๋ฒ์งธ ๊ฐ์ผ๋ก push ํด์ค๋ค. ๊ทธ๋ฆฌ๊ณ ๋จ์ A, B์ ์์๋ค์ ๋ํด ์ฌ๊ท์ ์ผ๋ก ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด ์๋กญ๊ฒ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ์ป์ ์ ์๋ค.
vector<int> merge(vector<int> a, vector<int> b) {
if (a.size() == 0)
return b;
if (b.size() == 0)
return a;
// ์ฌ๊ท์ ๋ณํฉ๊ณผ์
if (a[0] < b[0]) {
vector<int> target;
target.push_back(a[0]);
a.erase(a.begin());
vector<int> p = merge(a, b);
target.insert(end(target), begin(p), end(p));
return target;
}
else {
vector<int> target;
target.push_back(b[0]);
b.erase(b.begin());
vector<int> p = merge(a, b);
target.insert(end(target), begin(p), end(p));
return target;
}
}
๐ ์๊ฐ๋ณต์ก๋
๋ณํฉ์ ๋ ฌ์ ์๊ฐ๋ณต์ก๋๋ nlogn์ผ๋ก ์์ ๋ค๋ค๋ ์ฝ์ , ๋ฒ๋ธ ์ ๋ ฌ์ n^2 ๋ณด๋ค ํจ์ฌ ํจ์จ์ ์ด๋ค. ์ด์งํ์์ด๋ ์ด์ง๋ณํฉ ๋ฑ '์ด์ง(binary)'์ด ๋ค์ด๊ฐ๋ฉด ๋ชจ๋ logn ์๊ฐ์ผ๋ก ๊ณ์ฐ๋๋ค. ์ค์ ๊ฐ ์์๋ง๋ค ์ ๋ ฌํ๋ ๋ฐ ๋๋ ์๊ฐ์ '1' ์๊ฐ(1๋ฒ๋ง ๋น๊ตํ๋ฉด ๋จ)์ด๋ฏ๋ก ์ดn์๊ฐ์ด ๋ ๋ค(n๋ฒ ๋น๊ตํ๋๊น). ์ด์ ๋ฐ๋ผ n log n ์๊ฐ์ผ๋ก ์๊ฐ๋ณต์ก๋๋ฅผ ๊ณ์ฐํ ์ ์๋ค.
- ๋ ๋ฆฌ์คํธ ๋ณํฉ์ ์ต์ ์๊ฐ๋ณต์ก๋ : ๋ ๋ฆฌ์คํธ๊ฐ ์๋ก ๊ต์ฐจ๋๋ ๋ถ๋ถ์ด ์์ ๋ n/2
- ๋ ๋ฆฌ์คํธ ๋ณํฉ์ ์ต์ ์๊ฐ๋ณต์ก๋ : ๋ ๋ฆฌ์คํธ๊ฐ ์๋ก ๋ชจ๋ ๊ต์ฐจํ ๋ n
- ๊ณต๊ฐ๋ณต์ก๋ : A, B๋ฅผ ๋ชจ๋ ๋ณต์ฌํ๋ ๊ฒฝ์ฐ 2n ๊ณต๊ฐ ์ฐจ์ง (linked-list ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๊ตฌํํ๋ฉด n์ผ๋ก ๋จ์ถ๊ฐ๋ฅ)
'Problem Solving > Algorithm, DS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ๊ธฐ์์ ๋ ฌ, ๊ณ์์ ๋ ฌ Radix, Counting Sort (C++ ๊ตฌํ) (0) | 2021.01.04 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ํ ์ ๋ ฌ Heap Sort (C++ ๊ตฌํ, make_heap, pop_heap) (0) | 2021.01.03 |
[์๊ณ ๋ฆฌ์ฆ] ํต์ ๋ ฌ Quick Sort (C++ ๊ตฌํ) (0) | 2021.01.03 |
[์๊ณ ๋ฆฌ์ฆ] ์ฝ์ ์ ๋ ฌ Insertion Sort (C++ ๊ตฌํ) (0) | 2020.12.31 |
[์๊ณ ๋ฆฌ์ฆ] ๋ฒ๋ธ์ ๋ ฌ Bubble Sort (C++ ๊ตฌํ) (0) | 2020.12.30 |