๋ฐ์ํ
๐ ๋ณํฉ ์ ๋ ฌ(merge sort) ์ด๋
- ๋ถํ ์ ๋ณต์ ํ์ฉํ์ฌ ๊ตฌํํ๊ธฐ ๋๋ฌธ์ ์๊ฐ๋ณต์ก๋๋ O(nlogn) ํต์ ๋ ฌ๊ณผ ๋น์ท
-
๋ถํ ์ ๋ณต: ๋ฌธ์ ๋ฅผ ์์ 2๊ฐ์ ๋ฌธ์ ๋ก ๋ถ๋ฆฌํ๊ณ ๊ฐ๊ฐ ํด๊ฒฐํ ํ, ๋ค์ ๋ชจ์ ์๋์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ.
๋ณดํต ์ฌ๊ทํจ์ ํธ์ถ์ ์ด์ฉํ์ฌ ๊ตฌํ๋ค. - ํต์ ๋ ฌ๊ณผ ๋ค๋ฅธ ์ ์ด ์๋ค๋ฉด ํต์ ๋ ฌ์ ๊ฒฝ์ฐ pivot๊ฐ์ ๋ฐ๋ผ ํธํฅ๋๊ฒ ๋ถํ ๋ ์ ์๋ ๊ฐ๋ฅ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ ์ต์ ์ ๊ฒฝ์ฐ O(n^2)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค. ๊ทธ๋ฌ๋ ๋ณํฉ์ ๋ ฌ์ ๊ฒฝ์ฐ ์ ํํ ๋ฐ์ฉ ๋๋๋ค๋ ์ ์์ ์ต์ ์ ๊ฒฝ์ฐ์๋ O(nlogn)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๋ณด์ฅํ๋ค.
- ๋ง์ฝ 8๊ฐ์ ์ซ์๋ฅผ ์ ๋ ฌํ๋ค๊ณ ํ์. 8์์ 4๋ก ๋๋๊ณ , 4์์ 2๋ก ๋๋๊ณ , 2์์ 1๋ก ๋๋๋ค. ์ฆ 3๋ฒ ๋๋ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก ๋๋๋ ๊ฒ์ 3 = log8 ์ด๋ฏ๋ก logn์ด๋ค.
๋๋ ์ซ์์ ๋์๋ฅผ ๋น๊ตํ๋ ๊ฒ: [1,3], [2,4] ๋ฅผ ์ ๋ ฌํด๋ณด๋ฉด
1: 1 ์ด 2๋ณด๋ค ์์ผ๋ฏ๋ก [1]
2: 2๊ฐ 3๋ณด๋ค ์์ผ๋ฏ๋ก [1,2]
3: 3์ด 4๋ณด๋ค ์์ผ๋ฏ๋ก [1,2,3]
4: ๋ง์ง๋ง ๋จ์ ๊ฒ [1,2,3,4]
4๋ฒ ์ฐ์ฐํ๋ค. N๋งํผ ์ฐ์ฐ
๊ทธ๋์ ์๊ฐ๋ณต์ก๋๋ n*logn - ๋น๊ต ์ ๋ ฌ ( ๋ค๋ฅธ ์์์์ ๋น๊ต )
- ์์ฐจ์ ์ธ ๋น๊ต๋ฅผ ํตํด ์ ๋ ฌ์ ์งํํ๋ฏ๋ก LinkedList๋ฅผ ์ ๋ ฌํ ๋ ์ฌ์ฉํ๋ฉด ํจ์จ์ ์ด๋ค.
(LinkedList๋ ์ฝ์ ์ญ์ ์ฐ์ฐ์์ ์ ์ฉํ์ง๋ง ์ ๊ทผ ์ฐ์ฐ์์๋ ๋นํจ์จ์ ์ด๋ฏ๋ก)
๐ ๋ณํฉ ์ ๋ ฌ(merge sort) ์์
- ๋ถํ ์ ๋ณต(divide and conquer)๋ฅผ ์ด์ฉ - ์ฌ๊ทํจ์๋ก ๊ตฌํ
- ๋จผ์ ๋ฆฌ์คํธ๋ฅผ ๋ฐ์ฉ ์ชผ๊ฐ ๋ค . ๋ ์ด์ ์ชผ๊ฐค ์ ์์ ๋ ๊น์ง ๋ถํ
- ๋ค์ ๋ณํฉํ๋ฉด์ ์ ๋ ฌํด ๋์๊ฐ๋ค.
- ํฉ์น๋ ๋ฐฉ๋ฒ์ ๊ฐ์ฅ ์ผ์ชฝ ๋งจ์๋๋ถํฐ ์์ํ๋ค.
๐ ๋ณํฉ ์ ๋ ฌ(merge sort) ๊ตฌํ
def merge_sort(div_numbers):
if len(div_numbers) > 1:
print(f'์ชผ๊ฐ๊ธฐ: {div_numbers}')
mid = len(div_numbers) // 2
left_numbers = merge_sort(div_numbers[:mid])
right_numbers = merge_sort(div_numbers[mid:])
i, j, k = 0, 0, 0 # ์ผ์ชฝ๋ฆฌ์คํธ ์ธ๋ฑ์ค, ์ค๋ฅธ์ชฝ ๋ฆฌ์คํธ ์ธ๋ฑ์ค, ํตํฉ๋ฆฌ์คํธ์ธ๋ฑ์ค
while i < len(left_numbers) and j < len(right_numbers):
if left_numbers[i] < right_numbers[j]:
div_numbers[k] = left_numbers[i]
i += 1
else:
div_numbers[k] = right_numbers[j]
j += 1
k += 1
# ๋์ค ํ์ชฝ์ ๋ฆฌ์คํธ๋ฅผ ๋ค ์ผ์
while i < len(left_numbers):
div_numbers[k] = left_numbers[i]
i += 1
k += 1
while j < len(right_numbers):
div_numbers[k] = right_numbers[j]
j += 1
k += 1
print(f'ํฉ์น๊ธฐ: {div_numbers}')
return div_numbers
numbers = [4, 2, 8, 6, 0, 5, 1, 7, 3, 9]
print(f'์ ๋ ฌ ์ : {numbers}')
print()
merge_sort(numbers)
print()
print(f'์ ๋ ฌ ํ: {numbers}')
๐ ๋ณํฉ ์ ๋ ฌ(merge sort) ํน์ง
- ์ฅ์
- ์ต์ ์ ์๊ฐ๋ณต์ก๋๊ฐ O(nlogn)์ด๋ค.
- ํฐ ๋ฐ์ดํฐ์ ์์ ๋งค์ฐ ํจ์จ์ ์ด๋ค.
- ์์ ์ ๋ ฌ
- ๋จ์
- ์ถ๊ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํ๋ค. (์ ๋ ฌํ ๋ฐฐ์ด์ ์์๋ก ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ฏ๋ก)
๐ ๋ณํฉ ์ ๋ ฌ(merge sort) ์ฐธ๊ต์๋ฃ
๋ฐ์ํ
'CS > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋๋น ์ฐ์ ํ์(Breath First Search, BFS) (0) | 2020.09.27 |
---|---|
๊ณ์ ์ ๋ ฌ(counting sort) (0) | 2020.09.26 |
ํต ์ ๋ ฌ(quick sort) (1) | 2020.09.24 |
์ฝ์ ์ ๋ ฌ(insertion sort) (0) | 2020.09.23 |
์ ํ ์ ๋ ฌ(selection sort) (0) | 2020.09.22 |