๋ณํฉ ์ ๋ ฌ์ ๊ฐ๋
๋ณํฉ ์ ๋ ฌ์ด๋?
ํ๋์ ๋ฆฌ์คํธ๋ฅผ ๋ ๊ฐ์ ๊ท ๋ฑํ ํฌ๊ธฐ๋ก ์ต๋ํ ๋ถํ ํ๊ณ ๋ถํ ๋ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ์์๋๋ก ํฉํ๋ ๋ฐฉ์์ด๋ค.
๋ถํ ๋ ๋ฆฌ์คํธ๋ฅผ ์์๋๋ก ํฉ์ณ์ ๋ด๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ๊ฐ ์ถ๊ฐ์ ์ผ๋ก ํ์ํ๋ค.
๊ฐ์ฅ ์์ ๋จ์๋ก ์ ๋ฐ์ฉ ์ชผ๊ฐ ํ ๊ฐ์ฅ ์์ ๋จ์๋ถํฐ ๋ค์ ํฉ์ณ๋๊ฐ๋๋ฐ ์ด ํฉ์ณ๋๊ฐ๋ ๊ณผ์ ์์ ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ์ด ๋๋ค.
Divide and Conquer
- Merge Sort์ ํด๊ฒฐ ์ ๋ต
- ๋ฌธ์ ๋ฅผ ์์ 2๊ฐ์ ๋ฌธ์ ๋ก ๋ถ๋ฆฌํ๊ณ ๊ฐ๊ฐ์ ํด๊ฒฐํ ๋ค์, ๊ฒฐ๊ณผ๋ฅผ ๋ชจ์์ ์๋์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ ๋ต
- Divide and Conquer ๋ฐฉ์์ ๋๊ฐ ์ฌ๊ท ํธ์ถ์ ์ด์ฉํ์ฌ ๊ตฌํํจ
๋์ ๋ฐฉ์๊ณผ ๊ตฌํ
1. ๋ฐ์ดํฐ๋ค์ ์ ๋ฐ์ผ๋ก ๋๋๋ค. (๋ถํ )
2. ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ์์ ๋จ์๋ก ๋ถํดํ ํ ๋งจ ๋ฐ์์ ๋ถํฐ ์ฐจ๋ก๋๋ก ํฉ๋ณ์ ์งํํ๋ค. (์ ๋ณต)
2-1. ๋๊ฐ์ ๋ฐฐ์ด ์ค ํ๋๋ผ๋ ์์ ์ ๋ฒ์๋ฅผ ๋ฒ์ด๋ ๋ ๊น์ง ๋ฐ๋ณตํ๋ค.
2-1-1 . ๋๊ฐ๋ก ๋๋์ด์ง ๋ฐฐ์ด์ ์์๋ฅผ ์์์๋ถํฐ ์ฐจ๋ก๋๋ก ๋น๊ตํ๋ค.
2-1-2. ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ๊ธฐ์ค์ผ๋ก ๋๊ฐ์ ์์ ์ค ์์ ์์๋ฅผ ๋ณ๊ฐ์ ๋ฆฌ์คํธ์ ์ฝ์ ํ๋ค.
2-1-3. ์ฝ์ ๋ ์์๋ฅผ ๊ฐ์ง ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ฅผ ๋ค์ ์นธ์ผ๋ก ์ด๋์ํจ๋ค.
2-2. ๋จ์ ์๋ ๋ฐ์ดํฐ๋ค์ ๋ฆฌ์คํธ์ ๋ชจ๋ ์ฝ์ ํ๋ค.
๋๊ฐ์ ๋๋์ด์ง ๋ฐฐ์ด์ ์์ฐจ์ ์ผ๋ก ๋น๊ตํ์ฌ ์ ๋ ฌ์ด ๊ฐ๋ฅํ ์ด์ ๋ ๋๋์ด์ง ๋ฐฐ์ด์ด ์ด๋ฏธ ์ ๋ ฌ์ด ๋์ด์๋ ์ํ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
→ Method Stack์ ํ์ ์ ์ถ์ด๋๊น, ๊ฐ์ฅ ๋ง์ง๋ง์ ํธ์ถ๋ ๋ฉ์๋๊ฐ ๋จผ์ ์๋ฃ๋๊ธฐ ๋๋ฌธ
๊ตฌํ ์ฝ๋
void merge(int left, int right, int mid) {
int[] buffer = new int[right-left+1];
int bufferIdx = 0, l = left, r = mid+1;
while(l <= mid && r <= right) {
if(numbers[l] < numbers[r]) {
buffer[bufferIdx++] = numbers[l++];
}
else {
buffer[bufferIdx++] = numbers[r++];
}
}
while(l <= mid) {
buffer[bufferIdx++] = numbers[l++];
}
while(r <= right) {
buffer[bufferIdx++] = numbers[r++];
}
for(int i=left; i<=right; i++) {
numbers[i] = buffer[i-left];
}
}
void divide(int left, int right) {
if(left < right) {
int mid = (left + right)/2;
divide(left, mid);
divide(mid+1, right);
merge(left, right, mid);
}
}
๋ณํฉ ์ ๋ ฌ์ ์ฅ๋จ์
์ฅ์
- stable sort ๋ฐฉ๋ฒ์ด๊ธฐ ๋๋ฌธ์, ๋ ๊ฐ์ ํค๊ฐ์ ๊ฐ์ง๊ณ ์ ๋ ฌ์ ์๋ํ ์ ์์
๋จ์
- ๋ฐฐ์ด๋ก ๊ตฌ์ฑํ๊ฒ ๋๋ค๋ฉด, ๋ณ๋์ ์ ์ฅ ๊ณต๊ฐ์ด ํ์ํจ
- ์์ ๋ฐฐ์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ์ฎ๊ฒจ์ค์ผ ํ๋ฉฐ, ์ฌ์ง์ด ๋ณธ๋ ๋ฐฐ์ด๋ก ๋ณต์ฌ๊น์ง ํด์ผํ๋ฏ๋ก ๊ฐ์ ์ด๋์ด ๋ง์
๋ณํฉ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋
์๊ฐ ๋ณต์ก๋
Recursion Tree๋ฅผ ๊ทธ๋ ธ์ ๋ Tree์ ๋์ด(k)๋
n/2^k = 1 ์ด๋ฏ๋ก, k = lgn์ด๋ค.
Tree์ ๊ฐ ์ธต์ ๋ฐ์ดํฐ ์๊ฐ ๋์ผํ๊ฒ n์ด๋ฏ๋ก ์๊ฐ๋ณต์ก๋๋
O(n * lgn)์ด๋ค.
ํต ์ ๋ ฌ๊ณผ ๋ค๋ฅด๊ฒ ๋ฌด์กฐ๊ฑด ์ ๋ฐ์ผ๋ก ๋ฐฐ์ด์ ๋๋๊ธฐ ๋๋ฌธ์ ํ๊ท , ์ต์ , ์ต์ ๋ชจ๋ ๋์ผํ๊ฒ O(nlgn)์ด๋ค.
ํต์ ๋ ฌ๊ณผ ํฉ๋ณ์ ๋ ฌ์ ์ฐจ์ด์
- ํต์ ๋ ฌ : ์ฐ์ ํผ๋ฒ์ ํตํด ์ ๋ ฌ → ์์ญ์ ์ชผ๊ฐฌ
- ํฉ๋ณ์ ๋ ฌ : ์์ญ์ ์ชผ๊ฐค ์ ์์ ๋งํผ ์ชผ๊ฐฌ → ์ ๋ ฌ