์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
- ์ค๋ธ์
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ์๊ณ ๋ฆฌ์ฆ
- ๋๋น์ฐ์ ํ์
- ๊ตฌํ
- ๊ทธ๋ํ
- ํ๋ก๊ทธ๋๋จธ์ค
- LIS
- db
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- ์์ํ์
- ์๋ฃ๊ตฌ์กฐ
- ๊ทธ๋ฆฌ๋
- ํ์ด์ฌ
- ์ฐ์ ์์ํ
- ๊ทธ๋ํํ์
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- DFS
- ์ํ
- ๋์ ๊ณํ๋ฒ
- DP
- ๋ฐฑ์ค
- ๊น์ด์ฐ์ ํ์
- ์ ๋ ฌ
- SQL
- ๋จธ์ง์ํธ
- ๋ณํฉ์ ๋ ฌ
- ์์๊ตฌํ๊ธฐ
- ๋์ ํฉ
- BFS
๐๐ญ๐ฐ๐ธ ๐ฃ๐ถ๐ต ๐ด๐ต๐ฆ๐ข๐ฅ๐บ
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ - 1. ๋ณํฉ ์ ๋ ฌ(Merge Sort) ๋ณธ๋ฌธ
1. ๋ณํฉ ์ ๋ ฌ ; Merge Sort
1.1 ๊ฐ๋
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ ๋ํ์ ์ธ ์ ๋ ฌ ๋ฐฉ๋ฒ ์ค ํ๋๋ก, ์ฌ๋ฌ ์ ๋ ฌ๋ ์งํฉ๋ค์ ๋ณํฉํ์ฌ ํ๋์ ์ ๋ ฌ๋ ์งํฉ์ผ๋ก ๋ง๋๋ ์ ๋ ฌ๋ฐฉ๋ฒ์ ์๋ฏธํ๋ค. ๋ณํฉ ์ ๋ ฌ์ ๋ค์ ์ธ ๊ฐ์ง์ ๋จ๊ณ๋ฅผ ํตํด ์งํ๋๋ค.
1. ๋ถํ (Divide) : ํฐ ์งํฉ์ ๋ถ๋ถ์งํฉ์ผ๋ก ๋ถํ
2. ์ ๋ณต(Conquer) : ๋ถ๋ถ์งํฉ ๋ด์ ์์ ์ ๋ ฌ
3. ๊ฒฐํฉ(Combine) : ์ ๋ ฌ๋ ๋ถ๋ถ์งํฉ๋ค์ ํ๋์ ์งํฉ์ผ๋ก ์ ๋ ฌํ์ฌ ๊ฒฐํฉ
์๋ฆฌ๋ง ์๊ฐํ๋ฉด ๋ณต์กํด ๋ณด์ด์ง๋ง, ๊ทธ๋ฆผ๊ณผ ํจ๊ป ๋ณด๋ฉด ์ฝ๊ฒ ์ดํดํ ์ ์๋ค.
์ ๋ ฌ๋์ง ์์ ์งํฉ A๋ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌ์ฑ๋์ด์๋ค.
A = { 3, 8, 7, 2, 5, 1, 4, 6 }
์งํฉ A๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค๊ณ ๊ฐ์ ์ ํด๋ณด์. ๋ณํฉ ์ ๋ ฌํ๋ ๊ณผ์ ์ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ๋ค.
์งํฉ A๋ฅผ ๋ ์ด์ ๋ถํด๋์ง ์๋ ๊ฐ์ฅ ์์ ํฌ๊ธฐ์ ๋ถ๋ถ์งํฉ์ผ๋ก ๋ถํ ํ ๋ค์(1~4๋จ๊ณ), ๋ฐฐ์ด์ ํฉ์น๋(๊ฒฐํฉ) ๊ณผ์ ์์ ์ค๋ฆ์ฐจ์์ ์ ์งํ๋ฉฐ ์ ๋ ฌํ๋ค(5~7๋จ๊ณ). ์ด ๋ ์งํฉ ๋ช ๊ฐ๋ฅผ ๊ฒฐํฉํ์ฌ ํ๋์ ์งํฉ์ผ๋ก ๋ง๋ค ๊ฒ์ธ์ง์ ๋ฐ๋ผ n-way ๋ณํฉ์ด๋ผ๊ณ ๋ถ๋ฅด๋๋ฐ, ์์ ์์๋ก ๋ ๋ณํฉ ๋ฐฉ๋ฒ์ ๋ ๊ฐ์ ์งํฉ์ ๊ฒฐํฉํ์ฌ ํ๋์ ์งํฉ์ผ๋ก ๋ง๋ค์๊ธฐ ๋๋ฌธ์ 2-way ๋ณํฉ ์ ๋ ฌ์ด๋ค.
1.2 ๊ตฌํ
์ฝ๋๋ ํฌ๊ฒ ๋ ํจ์๋ก ๋๋ ์ ์๋ค. ์ ๋ ฌ์ ์คํํ๋ merge() ํจ์์ ๋ถํ ๊ณผ ์ ๋ ฌ์ ์ฌ๊ท์ ์ผ๋ก ํธ์ถํ๋ mergeSort() ํจ์๋ก ๋๋๋ค. ๋ณํฉ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ ํญ์ O(n log n)์ผ๋ก ์ต์ ์ ๊ฒฝ์ฐ O(n^2)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๋ ํต ์ ๋ ฌ์ ๋นํด ๋น ๋ฅธ ์ฅ์ ์ด ์์ง๋ง, ์ถ๊ฐ์ ์ธ ๋ฐฐ์ด ๊ณต๊ฐ์ด ํ์ํ๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ๋นํจ์จ์ ์ผ ์ ์๋ค.
#1. merge(int* sorted, int* arr, int begin, int mid, int end)
void merge(int* sorted, int* arr, int begin, int mid, int end) {
int i, j, k;
i = begin; // ์ฒซ ๋ฒ์งธ ๋ถ๋ถ์งํฉ์ ์ฒซ ๋ฒ์งธ ์์
j = mid + 1; // ๋ ๋ฒ์งธ ๋ถ๋ถ์งํฉ์ ์ฒซ ๋ฒ์งธ ์์
k = begin; // ๋ณํฉํ ์งํฉ์ ์ฒซ ๋ฒ์งธ ์์
while(i <= mid && j <= end) {
if(arr[i] <= arr[j]) {
sorted[k] = arr[i];
i++;
}
else {
sorted[k] = arr[j];
j++;
}
k++;
}
if(i > mid) {
for(int a = j; a <= end; a++, k++)
sorted[k] = arr[a];
}
else {
for(int a = i; a <= mid; a++, k++)
sorted[k] = arr[a];
}
for(int a = begin; a <= end; a++)
arr[a] = sorted[a];
}
#2. mergeSort(int* sorted, int* arr, int begin, int end)
void mergeSort(int* sorted, int* arr, int begin, int end) {
int mid;
if(begin < end) {
mid = (begin + end) / 2;
mergeSort(sorted, arr, begin, mid); // ์ผ์ชฝ ๋ถ๋ถ์งํฉ ๋ถํ
mergeSort(sorted, arr, mid + 1, end); // ์ค๋ฅธ์ชฝ ๋ถ๋ถ์งํฉ ๋ถํ
merge(sorted, arr, begin, mid, end); // ๋ถ๋ถ์งํฉ ๋ณํฉ
}
}
'์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ด๋ถ ํ์(Binary Search) (0) | 2021.08.08 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ํ ์ํ ๋ฌธ์ - 2. ๋๋น ์ฐ์ ํ์(BFS) (0) | 2021.07.22 |
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ํ ์ํ ๋ฌธ์ - 1. ๊น์ด ์ฐ์ ํ์(DFS) (0) | 2021.07.21 |
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ - 2. ํต ์ ๋ ฌ(Quick Sort) (0) | 2021.07.15 |
[์๊ณ ๋ฆฌ์ฆ] ๋์ ๊ณํ๋ฒ(Dynamic Programming) (0) | 2021.07.09 |