๋ณํฉ ์ ๋ ฌ์ ์ด๋ ํ ๋ฌธ์ ๋ฅผ ์ฐ์ ์์ ๋ฌธ์ ๋ก ์ชผ๊ฐ๊ณ ๋ ํ ๋ค์ ์กฐํฉํ์ฌ ์๋์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ
์ค ํ๋์ ๋๋ค.
- ์ฃผ์ด์ง ๋ฐฐ์ด์ ์ ๋ฐ์ผ๋ก ๋ถํ ํ์ฌ ๋ถ๋ถ๋ฐฐ์ด๋ก ๋๋๋๋ค.
- ํด๋น ๋ถ๋ถ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 1์ด ์๋๋ผ๋ฉด 1๋ฒ ๊ณผ์ ์ ๋ํ์ดํฉ๋๋ค.
- ์ธ์ ํ ๋ถ๋ถ๋ฐฐ์ด๋ผ๋ฆฌ ์ ๋ ฌํ๋ฉฐ ํฉ์นฉ๋๋ค.
- ๊ณต๊ฐ ๋ณต์ก๋
- ๋ค๋ฅธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ๋ค๊ณผ ๋ค๋ฅด๊ฒ ์ธ์ ํ ๊ฐ๋ค ๊ฐ์ ๊ตํ(swap)์ ์ผ์ด๋์ง ์์ต๋๋ค.
- ๋ ๊ฐ์ ๋ฐฐ์ด์ ๋ณํฉํ ๋ ๋ณํฉ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ ๋์ ๋ฐฐ์ด์ด ์ถ๊ฐ๋ก ํ์ํ๊ธฐ ๋๋ฌธ์ ๊ณต๊ฐ ๋ณต์ก๋๋
O(n)
์ ๋๋ค.
- ์๊ฐ ๋ณต์ก๋
- ์ ๋ฐ์ ์ธ ๋ฐ๋ณต์ ์๋ ์ ์ ์ ๋ฐ์ผ๋ก ์ค์ด๋ค๊ธฐ ๋๋ฌธ์ O(logN)์๊ฐ์ด ํ์ํ๋ฉฐ, ๊ฐ ํจ์ค์์ ๋ณํฉํ ๋ ๋ชจ๋ ๊ฐ๋ค์ ๋น๊ตํด์ผ ํ๋ฏ๋ก O(N) ์๊ฐ์ด ์๋ชจ๋ฉ๋๋ค.
- ๋ฐ๋ผ์ ์ด ์๊ฐ๋ณต์ก๋๋ ์ต์ , ํ๊ท , ์ต์
๋ชจ๋
O(NlogN)
์ ๋๋ค.
- ์ต์ , ์ต์
์ ๊ฒฝ์ฐ์๋
O(NlogN)
์ ์๊ฐ์ด ์์๋๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ ๋ถํฌ์ ์ํฅ์ ๋ ๋ฐ์ต๋๋ค. - ๋ง์ฝ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๊ตฌํํ๋ฉด, ๋งํฌ ์ธ๋ฑ์ค๋ง ๋น๊ฒฝ๋๋ฏ๋ก ๋ฐ์ดํฐ์ ์ด๋์ ๋ฌด์ ํ ์ ์์ ์ ๋๋ก ์์์ง๋๋ค.
- ํฌ๊ธฐ๊ฐ ํฐ ๋ ์ฝ๋๋ฅผ ์ ๋ ฌํ ๊ฒฝ์ฐ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ค๋ฉด, ํต ์ ๋ ฌ ํฌํจ ๋ค๋ฅธ ์ด๋ค ์ ๋ ฌ ๋ฐฉ๋ฒ๋ณด๋ค ํจ์จ์ ์ ๋๋ค.
in place
์๊ณ ๋ฆฌ์ฆ์ด ์๋๊ธฐ ๋๋ฌธ์ ๋ณ๋์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ํ์ํฉ๋๋ค.
๋ฌธ์
ํ์ด
์
๋ ฅ ๊ฐ๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๋ฌธ์ ์
๋๋ค.
๋ณํฉ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์ฌ ์ ๋ ฌํฉ๋๋ค.
def merge_sort(arr, first, last):
if first >= last:
return
merge_sort(arr, first, (first+last) // 2)
merge_sort(arr, (first+last) // 2 + 1, last)
return merge(arr, first, last)
def merge(arr, first, last):
mid = (first + last) // 2
i, j = first, mid+1
temp = []
while i <= mid and j <= last:
if arr[i] <= arr[j]:
temp.append(arr[i])
i += 1
else:
temp.append(arr[j])
j += 1
while i <= mid:
temp.append(arr[i])
i += 1
while j <= last:
temp.append(arr[j])
j += 1
for k in range(first, last+1):
arr[k] = temp[k-first]
return arr
n = int(input())
numbers = []
for _ in range(n):
numbers.append(int(input()))
for n in merge_sort(numbers, 0, n - 1):
print(n)
๋ณํฉ์ ๋ ฌ ์ ๋ ฌ๊ณผ์ ์ ๋ฐ๋ผ ๋ถํ - ์ ๋ณต - ๋ณํฉ
ํฉ๋๋ค.