- ๋ถํ ์ ๋ณต์๊ณ ๋ฆฌ์ฆ(Divide and Conquer)
๊ทธ๋ฅ ๋ง ๊ทธ๋๋ก, ๋ฐฐ์ด์ ๋ถํ ํ๊ณ , ํด๊ฒฐํ๊ณ , ... ์ด๋ฅผ ๋ฐ๋ณตํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
1. ๋ถํ : ํด๊ฒฐํ๊ณ ์ ํ๋ ๋ฌธ์ ๋ฅผ ์์ ํฌ๊ธฐ์ ๋์ผํ ๋ฌธ์ ๋ค๋ก ๋ถํ
2. ์ ๋ณต : ๊ฐ๊ฐ์ ์์ ๋ฌธ์ ๋ฅผ ์ํ์ ์ผ๋ก ํด๊ฒฐ
3. ํฉ๋ณ : ์์ ๋ฌธ์ ์ ํด๋ฅผ ํฉํ์ฌ(merge), ์๋ ๋ฌธ์ ์ ๋ํ ํด๋ฅผ ๊ตฌํจ
๋ํ์ ์ธ ๋ถํ ์ ๋ณต์๊ณ ๋ฆฌ์ฆ์๋ ํฉ๋ณ์ ๋ ฌ(merge sort)๊ณผ ํต์ ๋ ฌ(quick sort)์ด ์๋ค.
๋ถํ ์ ํ๋์ ํฐ ๋ฌธ์ ๋ฅผ ๊ฐ์ ์์ ๋ฌธ์ ๋ก ๋๋๋ ๊ฒ์ด๋ค. ์ด ๊ฐ๊ฐ์ ์์ ๋ฌธ์ ๋ค์ ์๋ ๋ฌธ์ ์ ๋์ผํ ๋ฌธ์ ์ฌ์ผ ํ๋ค.
์ ๋ณต์ด๋ผ๋ ์๋ฏธ๋ ๊ฐ๊ฐ์ ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ด๋ค.
์์ ๊ทธ๋ฆผ์ ํฉ๋ณ์ ๋ ฌ์ ๊ฐ๋จํ๊ฒ ํํํ ์์ด๋ค.
์๋ฅผ ๋ค์ด ์์ ๋ฐฐ์ด์์ ์ต๋๊ฐ์ ๊ตฌํ๋ ๋ฌธ์ ๋ฅผ ํผ๋ค๊ณ ๊ฐ์ ํ์.
์์ :
1. ํ๋์ ํฐ ๋ฌธ์ ๋ฅผ ๋์ผํ ํฌ๊ธฐ์ ์์ ๋ฌธ์ ๋ ๊ฐ๋ก ๋๋์๋ค. (๋ถํ . divide)
2. ๊ฐ๊ฐ์ ์์ ๋ฌธ์ ๋ ๊ฐ์์ ์ต๋๊ฐ์ ๊ฐ๊ฐ ๊ตฌํ๋ค. (์ ๋ณต. conquer)
3. ์ฒซ ๋ฒ์งธ ์์ ๋ฌธ์ ์์์ ์ต๋๊ฐ๊ณผ, ๋ ๋ฒ์งธ ์์ ๋ฌธ์ ์์์ ์ต๋๊ฐ์ ๋น๊ตํด ์ต์ข ์ ๋ฐฐ์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ค. (ํฉ๋ณ. merge)
๋ถํ ์ ๋ณต๋ฒ์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ํ(recursion)์ ์ด์ฉํ๋ค.
๋ ๋ค๋ฅธ ์๋ฅผ ๋ณด์.
์ด๊ธฐ ๋ฐฐ์ด์ 52471326์ด๋ค. ์ด๋ฅผ ํฉ๋ณ์ ๋ ฌํด 122345์ ์ ๋ ฌ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋๋ ์์ด๋ค.
ํฉ๋ณ์ ๋ ฌ์ Sudo Code (์์ฌ ์ฝ๋)
mergeSort(A[], p, r) // A[p... r]์ ์ ๋ ฌํ๋ค.
{
if (p < r) then {
q <- (p + q) / 2; // (1) p, q์ ์ค๊ฐ ์ง์ ๊ณ์ฐ
mergeSort(A, p, q); // (2) ์ ๋ฐ๋ถ ์ ๋ ฌ
mergeSort(A, q+1, r); // (3) ํ๋ฐ๋ถ ์ ๋ ฌ
merge(A, p, q, r); // (4) ํฉ๋ณ
}
}
merge(A[], p, q, r)
{
์ ๋ ฌ๋์ด ์๋ ๋ ๋ฐฐ์ด A[p...q]์ A[q+1... r]์ ํฉํ์ฌ
์ ๋ ฌ๋ ํ๋์ ๋ฐฐ์ด A[p...r]์ ๋ง๋ ๋ค.
}
์๋ฐ ์์ค ์ฝ๋
void merge (int data[], int p, int q, int r)
{
int i = p, j = q+1, k = p;
int tmp[data.length()];
while (i <= q && j <= r) {
if (data[i] <= data[j])
tmp[k++] = data[i++];
else
tmp[k++] = data[j++];
}
while (i <= q)
tmp[k++] = data[i++];
while (j <= r)
tmp[k++] = data[j++];
for (int i = p; i <= r; i++)
data[i] = tmp[i];
}
์๊ฐ๋ณต์ก๋
T(n) = 0 (n=1)
T(n/2) + T(n/2) + n (otherwise)
'์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
12-1๊ฐ. ๋ ๋๋ธ๋ํธ๋ฆฌ(1) (0) | 2020.11.17 |
---|---|
11-3๊ฐ. ์ด์ง๊ฒ์ํธ๋ฆฌ (Binary Search Tree) (3) | 2020.11.15 |
์ 11-1๊ฐ. ์ด์ง๊ฒ์ํธ๋ฆฌ(Binary Search Tree) (0) | 2020.11.10 |
์ 10๊ฐ ํธ๋ฆฌ์ ์ด์งํธ๋ฆฌ (0) | 2020.11.08 |
9๊ฐ. Java์์์ ์ ๋ ฌ (0) | 2020.11.05 |
๋๊ธ