[์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ] ํฉ๋ณ์ ๋ ฌ(Merge Sort)
ํฉ๋ณ์ ๋ ฌ, ๋จธ์ง์ํธ, ๋ณํฉ์ ๋ ฌ
ํฉ๋ณ์ ๋ ฌ์ ํต์ ๋ ฌ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ถํ ์ ๋ณต์ ์ด์ฉํด์ ์ ๋ ฌ์ ์ํํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ํต์ ๋ ฌ๊ณผ๋ ๋ค๋ฅด๊ฒ ํญ์ ๐ฉ(nlgn) ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๋ณด์ฅํ๋ค๋ ์ฅ์ ์ด ์์ง๋ง, ์ ๋ ฌ์ ์ํด ์ถ๊ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํฌ๊ฒ ์ฌ์ฉํ๋ค๋ ๋จ์ ์ด ์๋ค.
Algorithm Concept
ํฉ๋ณ์ ๋ ฌ์ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ํตํด ๋ฐฐ์ด์ ์์๋ค์ ์ ๋ ฌํ๊ฒ ๋๋ค. (์ค๋ฆ์ฐจ์)
- ๋๋์ด์ง ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 1์ด ๋ ๋๊น์ง ๋ฐฐ์ด์ ๋ฐ์ผ๋ก ๊ณ์ ๋๋๋ค.
- ๋๋์ด์ง ๋ฐฐ์ด์ ํฉ์น๋ฉด์ ์ ๋ ฌ์ ์ํํ๋ฉด์ ํฉ์น๋ค.
- ํฉ์น ๋๋ ํฉ์น ๋ ๋ฐฐ์ด์ ๊ธธ์ด์ ์ดํฉ๋งํผ์ ๋ณ๋ ๋ฐฐ์ด์ ์ค๋นํด์ ๋ ๋ฐฐ์ด์์ ์์ ์์๋๋ก ๊ฐ์ ธ์์ ๋ฐฐ์ด์ ๋ฃ์ด์ค๋ค.
Example
๋ง๋ก๋ง ํ๋ฉด ํท๊ฐ๋ฆฌ๋๊น ์๋ ๋ฐฐ์ด์ ๋จธ์ง์ํธ๋ก ์ ๋ ฌํ๋ ๊ณผ์ ์ ๋ฐ๋ผ๊ฐ๋ณด์.
Phase 1
Phase 2
Phase 3
Phase 4
Phase 5
Phase 6
- ํฉ์ณ์ผํ ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ๊ฐ๊ฐ 1, 2 ์ด๋ฏ๋ก ๊ธธ์ด 3์ง๋ฆฌ ๋ฐฐ์ด์ ์ค๋นํ๋ค.
- ๋จผ์ ๊ฐ ๋ฐฐ์ด์ ์ฒ์ ๊ฐ์ธ 3๊ณผ 2๋ฅผ ๋น๊ตํ๋ค. 2๊ฐ ๋ ์๊ธฐ ๋๋ฌธ์ 2๋ฅผ ์๋ก์ด ๋ฐฐ์ด์ ๋จผ์ ๋ฃ์ด์ค๋ค.
- 2 ๋ค์์ ๊ฐ์ด ์๊ธฐ ๋๋ฌธ์ ์ด๋ฒ์๋ 3๊ณผ 5๋ฅผ ๋น๊ตํด์ ๋ ์์ ๊ฐ์ ๋ฐฐ์ด์ ๋ฃ๋๋ค.
- ๋จ์ ๊ฐ์ด ํ๋์ด๋ฏ๋ก ์ด ๊ฐ์ ๋ง์ง๋ง์ผ๋ก ๋ฐฐ์ด์ ๋ฃ๋๋ค.
Phase 7 and More on
๊ณ์ ์งํํ๋ค๋ณด๋ฉด ๋ง์ง๋ง์ผ๋ก ํฉ์ณ์ฃผ๋ ๊ตฌ๊ฐ์ด ๋์ค๋๋ฐ, ํฉ์ณ์ฃผ๋ ๊ณผ์ ์ ๋ ์์ธํ๊ฒ ๋ณด๊ธฐ ์ํด ์ด ๊ตฌ๊ฐ์์ ํฉ์น๋ ๊ณผ์ ์ ํ๋จ๊ณ์ฉ ์์ธํ ํ์ธํด๋ณด์. ์ผ๋จ ๋ ๋ฐฐ์ด์ ๊ธธ์ด์ ํฉ์ธ 6๋งํผ์ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ค์๋ค.
Step 1
๋ ๋ฐฐ์ด์ ์์ ๊ฐ์ธ 2์ 1์ ๋น๊ตํด์ ๋ ์์ ๊ฐ์ ์ ๋ฐฐ์ด์ ๋ฃ์ด์ค๋ค.
Step 2
1์ ์ด๋ฏธ ์ฌ์ฉ๋ ๊ฐ์ด๋๊น ๊ฒ์ฌ ๊ฐ์ ๋ฐฐ์ด์ ๋ค์๊ฐ์ผ๋ก ๋ฐ๊ฟ์ค๋ค.
Step 3
์์ ๋ง์ฐฌ๊ฐ์ง๋ก 2 ์ 6์ ๋น๊ตํ๊ณ ๋ ์์ ๊ฐ์ธ 2๋ฅผ ์ ๋ฐฐ์ด์ ๋ฃ์ ๋ค, ๋ฐฐ์ด์ ์ฐธ์กฐ์์น๋ฅผ ํ์นธ ์ด๋์ํจ๋ค.
Step 4
3๊ณผ 6์ค ๋ ์์ ๊ฐ์ธ 3์ ๋ฐฐ์ด์ ๋ฃ๊ณ ์ฐธ์กฐ๊ฐ์ ํ์นธ ๋ค๋ก ์ด๋์ํจ๋ค.
Step 5
5์ 6 ์ค ๋ ์์ ๊ฐ์ธ 5๋ฅผ ๋ฐฐ์ด์ ๋ฃ๋๋ค. ์ด๋ฒ์๋ 5๊ฐ ๋ง์ง๋ง ๊ฐ์ด๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฅ ๋๋ธ๋ค.
Step 6
์ผ์ชฝ ๋ฐฐ์ด์ ๋ชจ๋ ์์์ ๋ํ ์ฒ๋ฆฌ๊ฐ ๋๋ฌ๊ธฐ ๋๋ฌธ์ ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์์ ์ฒ๋ฆฌ๊ฐ ์๋ ๊ฐ๋ค์ ์์ฐจ์ ์ผ๋ก ์ ๋ฐฐ์ด์ ์ฑ์์ค๋ค. ์ด๋ฏธ ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์ ๋ณํฉํ๋ ๊ณผ์ ์์ ์ ๋ ฌ์ด ๋์ด์๊ธฐ ๋๋ฌธ์ ์์๋๋ก ๋ฃ์ด์ฃผ๊ธฐ๋ง ํด๋ ์ ๋ ฌ์ ์ ์ง๋๋ค.
Implmentation
void merge (vector<int> & list, int left, int mid, int right){
vector<int> sorted_list(list.size());
int i = left, j = mid+1, idx = left;
while(i <= mid && j <= right){
if (list[i] <= list[j]){
sorted_list[idx++] = list[i++];
}
else{
sorted_list[idx++] = list[j++];
}
}
while(i <= mid){
sorted_list[idx++] = list[i++];
}
while(j <= right){
sorted_list[idx++] = list[j++];
}
for (int l = left ; l <= right ; l++){
list[l] = sorted_list[l];
}
}
void partition (vector<int> & list, int left, int right){
int mid;
if (left < right){
mid = (left + right) / 2;
partition(list, left, mid);
partition(list, mid+1, right);
merge(list, left, mid, right);
}
}
Alogrithm Analysis
๋จธ์ง์ํธ์ ์๊ฐ ๋ณต์ก๋๋ ๋ฐฐ์ด์ ๊ณ์ํด์ ๋ฐ์ผ๋ก ๋ถ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ์์ ์ด์งํธ๋ฆฌ์ ๋์ด์ธ lgn ๊ณผ ๋น๊ต์ฐ์ฐ์ ํตํด ์๋ก์ด ๋ฐฐ์ด์ ์ฑ์ฐ๋ ๊ณผ์ ์ด ๋ชจ๋ ๋จ๊ณ๋ง๋ค ์ํ๋๊ธฐ ๋๋ฌธ์ ๐ฉ(nlgn) ์ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
'๐ฎ ์จ-์์ค > ๐ ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ] ๊ธฐ์์ ๋ ฌ(Radix Sort) (0) | 2021.07.18 |
---|---|
[์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ] ๊ณ์์ ๋ ฌ(Counting Sort) (3) | 2021.07.18 |
[์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ] ํต์ ๋ ฌ(Quick Sort) (1) | 2021.07.18 |
[์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ] ํ๋ก์ด๋-์์ ์๊ณ ๋ฆฌ์ฆ(Floyd-Warshall Algorithm) (0) | 2021.07.18 |
[์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ] ์์์ ๋ ฌ(Topological Sort) (0) | 2021.07.18 |
๋๊ธ
์ด ๊ธ ๊ณต์ ํ๊ธฐ
-
๊ตฌ๋
ํ๊ธฐ
๊ตฌ๋ ํ๊ธฐ
-
์นด์นด์คํก
์นด์นด์คํก
-
๋ผ์ธ
๋ผ์ธ
-
ํธ์ํฐ
ํธ์ํฐ
-
Facebook
Facebook
-
์นด์นด์ค์คํ ๋ฆฌ
์นด์นด์ค์คํ ๋ฆฌ
-
๋ฐด๋
๋ฐด๋
-
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ
-
Pocket
Pocket
-
Evernote
Evernote