์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ๊ธฐ๋ณธ์ผ๋ก ํ๋ ํ(Heap) ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋กํ ์ ๋ ฌ ๋ฐฉ์์
๋๋ค.
์ต๋ ํ ํธ๋ฆฌ๋ ์ต์ ํ ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํด์ ์ ๋ ฌ์ ํฉ๋๋ค.
์์ ์ด์ง ํธ๋ฆฌ๋?
์ฝ์ ํ ๋ ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋๋ก ์ถ๊ฐํ๋ ์ด์ง ํธ๋ฆฌ
- ์ ๋ ฌํด์ผ ํ n๊ฐ์ ์์๋ฅผ ์ต๋ ๋๋ ์ต์ ํ์ผ๋ก ๊ตฌ์ฑํฉ๋๋ค.(์์ ์ด์ง ํธ๋ฆฌ ํํ)
- ํ์ฌ ํ ๋ฃจํธ๋ ์ต๋๊ฐ ๋๋ ์ต์๊ฐ์ด ์กด์ฌํฉ๋๋ค. ๋ฃจํธ์ ๊ฐ์ ๋ง์ง๋ง์์(๋ง๋จ ๋ ธ๋์ ๋ฐ๊พผ ํ์, ํ์ ์ฌ์ด์ฆ๋ฅผ ํ๋ ์ค์ ๋๋ค.
- ํ์ ์ฌ์ด์ฆ๊ฐ 1๋ณด๋ค ํฌ๋ฉด ์ ๊ณผ์ ๋ค์ ๋ฐ๋ณตํฉ๋๋ค.
- ๊ณต๊ฐ ๋ณต์ก๋
- ์ฃผ์ด์ง ๋ฐฐ์ด ์์์ ๊ตํ(swap)์ ํตํด, ์ ๋ ฌ์ด ์ํ๋๋ฏ๋ก O(n)์ ๋๋ค.
- ์๊ฐ ๋ณต์ก๋
- ํ ๊ตฌ์กฐ ์์ฑ์ ์ฐ์ฐ ์๋ ํ์ ๋์ด์ ๋์ผํ๋ฏ๋ก O(logN)์ด ๋ฉ๋๋ค.
- ๋ฐ๋ผ์ ํ ์ ๋ ฌ์ ์ ์ฒด ์๊ฐ ๋ณต์ก๋๋ ํ ์์ฑ(Heapify)์๊ณ ๋ฆฌ์ฆ ์๊ฐ ๋ณต์ก๋ O(logN) * ์ ์ฒด ๋ฐ์ดํฐ ์ N =
O(NlogN)
์ ๋๋ค.
- ์ต์ ์ ์ํฉ์๋ ์๊ฐ๋ณต์ก๋๊ฐ O(NlogN)์ด๋ผ ์ฑ๋ฅ์ด ์ข์ต๋๋ค.
- ๊ฐ์ฅ ํฐ ๊ฐ์ด๋ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ตฌํ ๋ ์ ์ฉํฉ๋๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ์๋๋ง ๋น๊ตํ๋ฉด ํต ์ ๋ ฌ์ด ํ๊ท ์ ์ผ๋ก ๋ ๋น ๋ฆ ๋๋ค. ๊ทธ๋์ ์์ฃผ ์ฌ์ฉํ์ง ์์ต๋๋ค.
๋ฌธ์
ํ์ด
์
๋ ฅ ๊ฐ๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๋ฌธ์ ์
๋๋ค.
์ต๋ ํ์ ์ด์ฉํ์ฌ HeapSort๋ก ์ ๋ ฌํฉ๋๋ค.
def heap_sort(arr):
n = len(arr)
for i in range(n//2 - 1, -1, -1): # ์ต๋ ํ ์ด๊ธฐํ
heapify(arr, n, i)
for i in range(n-1, 0, -1): # extract ์ฐ์ฐ
swap(arr, 0, i)
heapify(arr, i, 0)
def heapify(arr, n, i):
p = i
l = i * 2 + 1
r = i * 2 + 2
if l < n and arr[p] < arr[l]: # ์ผ์ชฝ ์์๋
ธ๋
p = l
if r < n and arr[p] < arr[r]: # ์ค๋ฅธ์ชฝ ์์๋
ธ๋
p = r
if i != p: # ๋ถ๋ชจ๋
ธ๋ < ์์๋
ธ๋
swap(arr, p, i)
heapify(arr, n, p)
def swap(arr, a, b): # ์์ ๊ตํ
arr[a], arr[b] = arr[b], arr[a]
n = int(input())
numbers = []
for _ in range(n):
numbers.append(int(input()))
heap_sort(numbers)
for n in numbers:
print(n)
์๋ฃ๊ตฌ์กฐ - ํ(Heap)
https://www.codesdope.com/course/algorithms-heapsort/