Heap
์ ์
์ฐ์ ์์ ํ
๋ฅผ ์ํ ์๋ฃ๊ตฌ์กฐ.์ฐ์ ์์ ํ๋ ์ค์ผ์ค๋ง(ex: CPU ์ค์ผ์ค๋ง)์ ์ฃผ๋ก ์ฐ์ธ๋ค.
๊ฐ์ฅ ํฐ ๋ฐ์ดํฐ๋ถํฐ ๋์ค๋ฉด Max Heap(์ต๋ ํ), ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๋ถํฐ ๋์ค๋ฉด Min Heap(์ต์ ํ)์ด๋ผ๊ณ ํ๋ค.
๊ตฌํ(Python) - Max Heap
๋ค์์ ๋ณ์๋ค์ด ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํ๋ค.
HEAP_SIZE = 0 # ํ์ ์กด์ฌํ๋ ์์์ ๊ฐ์๋ฅผ ์ ์ฅํ ๋ณ์
heap = [None] # ํ (0๋ฒ ์ธ๋ฑ์ค ๋ฏธ์ฌ์ฉ)
์ฝ์
# ํ์ ์ฝ์
์. ๋ฐ๋ณต ์ธ๋ฑ์ค i๋ ๋ฐฉ๊ธ ๋ค์ด๊ฐ ๋ฐ์ดํฐ์ ์ธ๋ฑ์ค๋ถํฐ ๋ฃจํธ์ ์์๊น์ง
# 1. ๋ง์ง๋ง ๋
ธ๋์ ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์
# 2. (์ต๋ ํ ๊ธฐ์ค) ๋ถ๋ชจ์ ๋น๊ตํด์ ๋ถ๋ชจ๋ณด๋ค ํฌ๋ฉด ๋ถ๋ชจ์ swap
# 3. ๋ถ๋ชจ๊ฐ ๋ ํฐ ๊ฐ์ผ ๋๊น์ง 2๋ฒ์ ๋ฐ๋ณต
def push(data):
global HEAP_SIZE
HEAP_SIZE += 1
heap.append(data)
i = HEAP_SIZE
while i > 1:
parent = i//2
if heap[i] <= heap[parent]:
break
heap[i], heap[parent] = heap[parent], heap[i]
i = parent
์ญ์
# ํ์์ ์ญ์ ์. ์ ํํ๋ ์ฐ์ ์์ ํ์์์ pop. ๊ฐ์ฅ ํฐ ์์๋ฅผ ๊บผ๋ด๋ ๊ฒ
# 1. ๋ฃจํธ ๋
ธ๋ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๊ณ ๋ฃจํธ ๋
ธ๋ ์์น์ ๋ง์ง๋ง ๋
ธ๋ ๊ฐ์ ๋ฃ๋๋ค.
# 2. ๋ง์ง๋ง ๋
ธ๋๋ฅผ ์ญ์ ์ฒ๋ฆฌ(ํ ํฌ๊ธฐ๋ฅผ 1 ์ค์ธ๋ค).
# 3. ํ์ ์ฌ์ ๋ ฌํ๋ค.
def pop():
global HEAP_SIZE
data = heap[1]
heap[1] = heap[HEAP_SIZE]
heap.pop()
HEAP_SIZE -= 1
sort()
return data
# ์ฌ์ ๋ ฌ: ๋ฃจํธ๋ถํฐ ์์ํด์ ๋ง์ง๋ง ๋
ธ๋๊น์ง ๋น๊ตํ๋ฉฐ swap
# ๋ด๊ฐ ๊ฐ์ฅ ํฌ๋ฉด ๋ด๋น๋๊ณ , ๋๋ณด๋ค ํฐ ์์์ด ์๋ค๋ฉด ๋ ํฐ ์์์ด๋ swapํ๋ค.
# ๋ ์์์ด ๋ชจ๋ ๋๋ณด๋ค ํฌ๋ค๋ฉด ๋ ์ค ๋ ํฐ ์์์ ์๋ก ์ฌ๋ ค์ผ max heap์ด ์ ์ง๋๋ค.
def sort():
global HEAP_SIZE
i = 1
while i*2 <= HEAP_SIZE:
max_index = i
if heap[max_index] < heap[i*2]:
max_index = i*2
if i*2 < HEAP_SIZE and heap[max_index] < heap[i*2+1]:
max_index = i*2+1
if max_index == i:
break
heap[max_index], heap[i] = heap[i], heap[max_index]
i = max_index
์๊ฐ๋ณต์ก๋
์ฝ์ ์ ๋งจ ๋ฐ์์ ๋งจ ์๊น์ง ์ฌ๋ผ์ค๋ ๊ณผ์ ์ด๋ฏ๋ก O(logN)์ด๋ค.
์ญ์ ๋ ์ญ์ ์์ฒด๋ O(1)์ด์ง๋ง ์ฌ์ ๋ ฌ ๊ณผ์ ์ด ํ์ํ๋ค. ์ฌ์ ๋ ฌ์ ๋ฃจํธ๊ฐ ์ต๋ ๋ง์ง๋ง ๋ ธ๋๊น์ง ๊ฒ์ฌํ๋ ๊ณผ์ ์ด๋ฏ๋ก ๋งจ ์์์ ๋งจ ๋ฐ๊น์ง ์ฌ๋ผ์ค๋ ๊ณผ์ ์ด๋ค. ๋ฐ๋ผ์, O(logN)์ด๋ค.
Last updated