Heap์ ๊ฐ๋
ํ์ ํธ๋ฆฌ์ ์ผ์ข ์ธ๋ฐ, "complete tree"์ด๊ฑฐ๋ "nearly complete tree"์ด์ด์ผ ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์ ๋ ๊ฐ์ง ์ข ๋ฅ๋ก ๋๋๋ค.
max-heap์ ๊ฒฝ์ฐ ๊ฐ ๋ ธ๋์ key ๊ฐ์ด ์์ ๋ ธ๋๋ค์ key ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , min-heap์ ๊ฒฝ์ฐ ๊ฐ ๋ ธ๋์ key ๊ฐ์ ์์ ๋ ธ๋๋ค์ key ๊ฐ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์์ผ ํ๋ค.
Heap์ ํน์ฑ
max-heap์ ๊ธฐ์ค์ผ๋ก ์ดํด๋ณด์. ํ์ root๋ ํธ๋ฆฌ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ฐ๊ณ ์์ผ๋ฉฐ, root์ ์ผ์ชฝ/์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ๋ ๊ฐ์ ํน์ฑ์ ์ ์งํ๋ค. ๋ง์ฝ min-heap์ด๋ผ๋ฉด ํ์ root๊ฐ ํธ๋ฆฌ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ฐ๊ฒ ๋๋ค.
๊ตฌํ์ ์ฃผ๋ก linked list๋ณด๋ค๋ array๋ก ์ด๋ฃจ์ด์ง๋ค.
๋ ธ๋์ ์์ ๊ฐ์ ๊ด๊ณ๋ ๋ค์๊ณผ ๊ฐ์ด ํ์ธํ ์ ์๋ค.
index๊ฐ i์ธ ๋ ธ๋๋ฅผ ์๊ฐํด๋ณธ๋ค๋ฉด,
-
- i๋ฒ์งธ ๋ ธ๋ ์ผ์ชฝ ์์: 2i+1
- i๋ฒ์งธ ๋ ธ๋ ์ค๋ฅธ์ชฝ ์์: 2i+2
- i๋ฒ์งธ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋: floor((i-2)/2)
- j๋ฒ์งธ ๋ ธ๋๊ฐ ์ผ์ชฝ ์์์ด๋ฉด, ์ค๋ฅธ์ชฝ ์์์ j+1
Heap์ ์ฐ์ฐ
Heap์์ ์๋ฃ๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ์ ์์ผ๋ฉฐ, ์ํ, ๊ฒ์, ์ถ๋ ฅ๊ณผ ๊ฐ์ ๊ธฐ๋ฅ๋ ์๋ํ๊ฒ ํ ์ ์๋ค.
๋ค๋ง ํ์ ์์์ ์ธ๊ธํ, root์ key ๊ฐ์ด ๊ฐ์ฅ ํฌ๊ฑฐ๋ (max-heap) ์์์ผ (min-heap) ํ๊ณ ๊ทธ ํน์ฑ์ด ๋ชจ๋ ์๋ธํธ๋ฆฌ์ ๋ํด์๋ ๋์ผํ๊ฒ ์ ์ง๋์ด์ผ ํ๋ฉฐ, ์ ์ํ๋ ๊ฒ์ฒ๋ผ (nearly) complete tree๋ผ๋ ํน์ฑ๋ ์ ์งํด์ผ ํ๋ค.
๋ง์ฝ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ๋ฅผ ํ ํ ๊ทธ๋ฅ ๊ฐ๋งํ ๋๋ค๋ฉด ํ์ ์ ์๋ฅผ ๋ง์กฑํ์ง ๋ชปํ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ ์ฐ๋ฆฌ๋ Reheap up / Reheap down ์ด๋ผ๋ ํจ์๋ฅผ ์ ์ํด์ heap์ ๋ชจ์์ ์ ์งํ๋๋ก ํ๋ค.
์๋์ฝ๋์ ๊ฒฝ์ฐ, ์ํ, ๊ฒ์, ์ถ๋ ฅ ์์ฒด๋ ๊ธฐ์กด ํธ๋ฆฌ์์ ๊ตฌํํ๋ ๊ฒ๊ณผ ๋์ผํ๋ฏ๋ก ๊ฑด๋๋ฐ๊ณ , ์ฝ์ ๋ฐ ์ญ์ ์ ๊ฒฝ์ฐ๋ ๊ฐ๊ฐ ํจ์์ ๋ท๋ถ๋ถ์์ Reheap up, Reheap downํจ์๋ฅผ ๋ถ๋ฌ์ค๊ธฐ๋ง ํ๋ฉด ๋๋ฏ๋ก ๊ฑด๋๋ฐ๋๋ก ํ๊ฒ ๋ค. ์ฌ๊ธฐ์์๋ Reheap Up ๋ฐ Reheap Down์ ๋ํด์๋ง ์๊ฐํ๋๋ก ํ๊ฒ ๋ค.
Reheap Up
์ฝ์ ์ฐ์ฐ์ ์ํํ๋ฉด์ ๊ฐ์ด ๋ถ๋ฌ์์ผ ํ๋ ํจ์๋ก ๊ฐ์ฅ ๋ง์ง๋ง์ ์ฝ์ ๋ ์์๋ฅผ ์์ชฝ์ผ๋ก ์ด๋์ํค๋ฉด์ ์ฌ๋ฐ๋ฅธ ์์น์ ๊ฐ ์ ์๊ฒ ํ๋ค. ์ฝ์ ์์ฒด๋ ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ ๋น leaf node์ ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์ heap์ ๊ตฌ์กฐ๋ฅผ ์ ์งํ๊ธฐ ์ํด์๋ node๋ฅผ ์ด๋์์ผ์ฃผ์ด์ผ ํ๋ค.
์ฝ์ ๋ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋์ key ๊ฐ์ ๋น๊ตํ์ฌ, ๋ง์ฝ ์ฝ์ ๋ ๋ ธ๋๊ฐ ๋ถ๋ชจ ๋ ธ๋์ key ๊ฐ๋ณด๋ค ํฌ๋ฉด ์๋ก ์์น๋ฅผ ๊ตํํ๋ค. ์ด ๊ณผ์ ์ ๊ณ์ ๋ฐ๋ณตํ์ฌ heap์ ๊ตฌ์กฐ๋ฅผ ์ ์ง์ํจ๋ค.
์๋์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
void reheapUp (HEAP *heap, NODE *newNode) {
if (newNode != root) {
parent = parent->newNode;
if (newNode->key > parent->key) {
swap(newNode, parent);
reheapUp(heap,parent);
}
}
}
Reheap Down
heap์ nearly complete tree์ด๋ฏ๋ก root์ ๋ฐ๋ก ์ญ์ ํ๊ฒ ๋๋ฉด, heap์ ๊ตฌ์กฐ๊ฐ ์ ์ง๋์ง ๋ชปํ๋ค. ๋ฐ๋ผ์ last tree node์ ๊ฐ์ root๋ก ์ฎ๊ธด ํ, root๋ฅผ ์๋๋ก ์ด๋์์ผ์ heap์ ๋ฐฐ์ด ํน์ฑ(heap-ordering property)์ด ์ถฉ์กฑ๋๋๋ก ์์น๋ฅผ ๋ณ๊ฒฝํด์ผํ๋ค.
root ๋ ธ๋๋ฅผ ์ญ์ ํ ๋, ๊ทธ๋ฅ ์ญ์ ํ๊ฒ ๋๋ฉด heap์ ๊ตฌ์กฐ๊ฐ ๋ถ๊ดด๋๋ฏ๋ก, ์์ ๋ ธ๋ ์ค ์ค๋ฅธ์ชฝ ๋ ธ๋์ ๊ฐ์ ๊ตํํด๊ฐ๋ฉฐ heap ๊ตฌ์กฐ์ ๋ง์ง๋ง ๋ ธ๋๋ก ์ด๋์ํจ ํ ์ญ์ ํ๋ค.
์๋์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
void reheapDown (HEAP *heap, NODE *root, int last) {
if (root->left) {
int leftKey = root->left->key;
if (root->right) {
int rightKey = root->right->key;
}
else {
int rightKey = NULL;
}
}
if (leftKey > rightKey) {
largeSubtree = root->left;
}
else {
largeSubtree = root->right;
}
if (root->key < largeSubtree->key) {
swap(root, largeSubtree);
reheapDown(heap, largeSubtree, last);
}
}