๊ตญ๋ฏผ๋ํ๊ต์์ "์ฝ๊ฒ ๋ฐฐ์ฐ๋ ์๊ณ ๋ฆฌ์ฆ" ๊ต์ฌ๋ฅผ ์ด์ฉํ
๋ฐํ๋ช ๊ต์๋์ ๊ฐ์ ๊ต์์ ์ด์ฉํ์ฌ ์์ ๋ด์ฉ์ ์ ๋ฆฌํ์์ต๋๋ค
Heapsort
Heapsort๋ ์ด๋ฆ ๊ทธ๋๋ก Heap ์๋ฃ๊ตฌ์กฐ๋ฅผ ํ์ฉํ๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด๋ค!
=> Heap์ด๋ Heap Property๋ฅผ ๋ง์กฑํ๋ Complete Binary Tree์!
(Complete Binary Tree๋ ๋ ธ๋๋ฅผ ์ฝ์ ํ ๋ ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋๋ก ์ฝ์ ํ๋ ํธ๋ฆฌ = ์ผ์ชฝ์ด ๋น์ด์์ ์ ์์)
Heap Property
(Min-Heap์ ๊ฒฝ์ฐ) ๊ฐ ๋ ธ๋์ ๊ฐ <= ์์ ๋ ธ๋์ ๊ฐ
(Max-Heap์ ๊ฒฝ์ฐ) ๊ฐ ๋ ธ๋์ ๊ฐ >= ์์ ๋ ธ๋์ ๊ฐ
=> Complete Binary Tree ์ด๋ฏ๋ก ์์ ๊ฐ์ด ๋ฐฐ์ด๋ก ๊ตฌํ์ด ๊ฐ๋ฅํจ!
Heap Operations์ ๊ฒฝ์ฐ (n์ Heap์ ์ ์ฅ๋ ๋ฐ์ดํฐ ์)
Find-Max : θ(1) - ์ต๋๊ฐ ์ฐพ๊ธฐ
Extract-Max(Sift down) : θ(log n) - ์ต๋๊ฐ ์ง์ฐ๊ธฐ(Heap ์ ์งํ๊ธฐ)
Insert : θ(log n) - ๊ฐ ๋ฃ๊ธฐ=> ๋ฐ์ ๋ถ์ด๊ณ ์๋ก ์ฌ๋ผ๊ฐ๋ฉฐ ์๋ฆฌ๋ฅผ ์ฐพ์
Build-Heap : θ(n) - Heap ๋ง๋ค๊ธฐ(Heap ๊ตฌ์กฐ๋ฅผ ๋ฐ๋ฅด๊ฒ ๋ฐ๊ฟ)
๊ทธ๋์ ๊ฒฐ๋ก ์ ์ผ๋ก Heapsort๋
- ์ฃผ์ด์ง ๋ฐฐ์ด์ Complete Binary Tree๋ก ๋ด
- Max-Heap Property๋ฅผ ๋ง์กฑํ๋๋ก Build-Heap์ ์ํํจ
- Extract-Max(= Swap ๋ฐ Sift down)๋ฅผ ๋ฐ๋ณตํ์ฌ ์ ๋ ฌ
๊ทธ๋ฆผ์ผ๋ก ์ดํด๋ณด๋ฉด
์ฒ์ ๋ฐฐ์ด์ build_heap ํ ๋๋ฅผ ์ดํด๋ณด๋ฉด
์์ฐจ์ ์ผ๋ก insert ํ๋ค๊ณ ํ๋ฉด ๋ฐ์ดํฐ๋ฅผ ํธ๋ฆฌ์ ๋์ด๋งํผ ์ํํ๋ฉด์ ์ฝ์ ํด์ผ ํ๊ธฐ ๋๋ฌธ์
log1 + log2 + log3 + ... + log(n-1) + logn ๋ผ๊ณ ๋ณผ ์ ์๊ณ ์ด๋ logn์ด n๊ฐ ์๋ ๊ฒ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ๋ฐ์ ์์
์ฆ, <= nlogn ๋ก ๋ณผ ์ ์๊ณ θ(nlogn) ์
์ด๋ ๊ฒ ํ ๊ตฌ์กฐ๋ฅผ ๋ฐ๋ฅด๊ฒ ๋ฐฐ์ด์ ๋ฐ๊ฟจ์ผ๋ฉด
Extract-max๋ฅผ ํตํด ๊ฐ์ฅ ํฐ ๊ฐ์ ๋ฐฐ์ด์ ๋ฝ์ ๋งจ ๋ค๋ก ๋ณด๋ด๋ฉฐ ํ์ ์ ์งํ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉฐ ์ ๋ ฌํจ
์ด ๊ณผ์ ๋ ๋ฃจํธ ๋
ธ๋์ ๋ง์ง๋ง ๋ฆฌํ ๋
ธ๋์ ์๋ฆฌ๋ฅผ ๋ฐ๊พธ๊ณ ํธ๋ฆฌ์ ๋์ด๋งํผ ๋ฐ์ดํฐ๋ฅผ ์ํํ๋ฉฐ ํ ๊ตฌ์กฐ๋ฅผ ์ ์งํ๊ธฐ ๋๋ฌธ์
(์ด ๋ ๋ฃจํธ ๋
ธ๋๊ฐ ์์ด์ง๋ฏ๋ก ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 1์ฉ ์ค์ด๋ฌ)
logn + log(n-1) + log(n-2) + ... + log2 + log1 ๋ก ๋ณผ ์ ์๊ณ ์ด๋ logn์ด n๊ฐ ์๋ ๊ฒ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ๋ฐ์ ์์
์ฆ, <= nlogn๋ก ๋ณผ ์ ์๊ณ θ(nlogn) ์
๊ทธ๋ผ build_heap์ ํ๊ณ Extract-Max๋ฅผ ๋ฐ๋ณตํ๋ ๊ณผ์ ์
ํฉ์น๋ฉด ๊ฒฐ๊ตญ θ(nlogn)์ด ๋จ
Sift down
๋ ธ๋์ ๋ ์์์ด ๋ชจ๋ Heap ์ผ ๋, ์์๊ณผ ์์ ์ ํ๋์ Heap์ผ๋ก ๋ง๋๋ ์ฐ์ฐ์
์ผ์ชฝ ๊ทธ๋ฆผ์ ๋ณด๋ฉด 88์ด ๋ถ๋ชจ๋ ธ๋์ด๊ณ ์์๋ ธ๋๊ฐ ๊ทธ ๋ณด๋ค ์์ 72, 48 ์ด๋ฏ๋ก Heap ๊ตฌ์กฐ์ธ ๊ฒ์ ์ ์ ์์ (Max-Heap ๊ธฐ์ค)
85๊ฐ ๋ถ๋ชจ๋ ธ๋์ธ ๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง
ํ์ง๋ง, ์ด ๋์ ์์์ผ๋ก ๊ฐ๋ ๋ถ๋ชจ ๋ ธ๋ 6์ ์ดํด๋ณด๋ฉด Heap ๊ตฌ์กฐ๊ฐ ์๋๊ธฐ ๋๋ฌธ์ Sift down์ ํตํด ์ด๋ฅผ ํ๋์ Heap์ผ๋ก ๋ง๋๋ ๊ฒ์ ๋ณผ ์ ์์!
siftdown ํ๋ ค๋ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์์ ๋ ธ๋๋ค ์ค ๋ ํฐ ๊ฐ์ ๊ฐ์ง ๋ ธ๋์ ๋น๊ตํ์ฌ ๋ง์ฝ ์์ ๋ ธ๋๊ฐ ๋ ํด ๊ฒฝ์ฐ ์์น๋ฅผ ๋ฐ๊พธ๊ณ
์ฌ๊ท์ ์ผ๋ก siftdown์ ํ๋ค๊ฐ ๋ฆฌํ ๋ ธ๋์ ๋๋ฌํ๊ฑฐ๋ ๋น๊ตํ๋ ค๋ ์์ ๋ ธ๋๋ณด๋ค siftdown์ ํ๋ ๋ ธ๋๊ฐ ๊ฐ์ด ๋ ํด ๊ฒฝ์ฐ ์ค์งํจ!
๊ทธ๋์ ๋ค์ ์๊น๋ก ๋์๊ฐ์ Heapsort์ ํ๋ฆ ์ค Extract-Max ๋ถ๋ถ์ ์ดํด๋ณด๋ฉด
build_heap์ ํตํด Heap์ด ์ฃผ์ด์ง๋ฉด Swap ๋ฐ Sift down ์ฐ์ฐ์ ๋ฐ๋ณตํ์ฌ ์ ๋ ฌํ๋ ๊ฒ์!
Build-Heap
Build-Heap์ Sift down ์ฐ์ฐ์ ๋ค์์ ๋ถํฐ ๋ฐ๋ณตํ๋ค๊ณ ์๊ฐํ๋ฉด ๋จ
์ผ๋จ Build-Heap์ Complete Binary Tree๊ฐ Heap Property๋ฅผ ๋ง์กฑํ๋๋ก ๊ฐ์ ์ฌ๋ฐฐ์นํจ
์์์ ๋งํ๋ค ์ถ์ด ์์ฐจ์ ์ผ๋ก insert ํ๋ค๊ณ ํ๋ฉด O(nlogn) ์ธ๋ฐ, O(n)์ ๊ฐ๋ฅํ ๊น?
def build_heap(arr) :
n = len(arr)
for i in range(n//2 - 1, -1, -1) :
siftdown(i, arr, n)
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด Heap์ด ์๋ ๋ ธ๋๋ถํฐ ์์ํด์ (๋ฆฌํ ๋ ธ๋๋ ๋ ธ๋๊ฐ ์๋ Heap์ผ๋ก ๋ณผ ์ ์์!)
Sift down ์ฐ์ฐ์ ๋ค์์๋ถํฐ ๋ฐ๋ณต ์ ์ฉํ๊ฒ ๋๋ฉด θ(n)์
์ฝ๋์์ siftdown์ n//2 - 1 ์์ ์์ํ๋ ์ด์
complete binary tree์์ internal node(๋ฆฌํ ๋ ธ๋๊ฐ ์๋ node) ์ค ๊ฐ์ฅ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ๊ฐ๋ฅดํด
Complexity Analysis of Build-Heap
์ ๋ฆฌ๋ฅผ ํด๋ณด์๋ฉด
๋น Heap์ ๊ฐ์ ํ๋์ฉ ๋ฃ๋๊ฑด
log1 + log2 + log3 + ... + log(n-1) + logn = θ(nlogn)
ํ์ง๋ง, Sift down ์ฐ์ฐ์ ๋ค์์๋ถํฐ ๋ฐ๋ณต ์ ์ฉํ๋ฉด
Worst case ์ ๊ฒฝ์ฐ θ(n)
Best case ์ ๊ฒฝ์ฐ๋ θ(n)
=> Sift down ์ n/2 ํ ์ํํ๊ฒ ๋จ!
์ด๋ฏ๋ก θ(n) ์!
๋ฐ๋ผ์, Heapsort์ ์๊ฐ๋ณต์ก๋๋ฅผ ์ดํด๋ณด๋ฉด
T(n) = θ(n) + θ(nlogn) = θ(nlogn)
์ฌ๊ธฐ์ ์์ θ(n)์ build-heap , θ(nlogn)์ swap, sift down์ ์๋ฏธํจ!
'๐ฅ Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
L07 - Selection (4) | 2024.10.13 |
---|---|
L06 - Non-comparison Sorting (2) | 2024.10.08 |
L04 - Merge Sort & Quicksort (2) | 2024.09.27 |
L03 - Basic Sorting Algorithms (1) | 2024.09.25 |
L02 - Recurrences (1) | 2024.09.17 |