# ํ(Heap)
# ์์์ผํ ๊ฒ
1.ํ์ ๊ฐ๋
2.ํ์ ์ฝ์ ๋ฐ ์ญ์
ํ์, ์ฐ์ ์์ ํ๋ฅผ ์ํด ๋ง๋ค์ด์ง ์๋ฃ๊ตฌ์กฐ๋ค.
๋จผ์ ์ฐ์ ์์ ํ์ ๋ํด์ ๊ฐ๋ตํ ์์๋ณด์
์ฐ์ ์์ ํ : ์ฐ์ ์์์ ๊ฐ๋ ์ ํ์ ๋์ ํ ์๋ฃ๊ตฌ์กฐ
๋ฐ์ดํฐ๋ค์ด ์ฐ์ ์์๋ฅผ ๊ฐ์ง๊ณ ์์. ์ฐ์ ์์๊ฐ ๋์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋๊ฐ
์คํ์ LIFO, ํ๋ FIFO
# ์ธ์ ์ฌ์ฉ?
์๋ฎฌ๋ ์ด์ ์์คํ , ์์ ์ค์ผ์ค๋ง, ์์นํด์ ๊ณ์ฐ
์ฐ์ ์์ ํ๋ ๋ฐฐ์ด, ์ฐ๊ฒฐ๋ฆฌ์คํธ, ํ์ผ๋ก ๊ตฌํ (ํ์ผ๋ก ๊ตฌํ์ด ๊ฐ์ฅ ํจ์จ์ !)
ํ โ ์ฝ์ : O(logn) , ์ญ์ : O(logn)
# ํ(Heap)
์์ ์ด์ง ํธ๋ฆฌ์ ์ผ์ข
์ฌ๋ฌ ๊ฐ ์ค, ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ์๋ด๋๋ก ๋ง๋ค์ด์ง ์๋ฃ๊ตฌ์กฐ
๋ฐ์ ๋ ฌ ์ํ
ํ ํธ๋ฆฌ๋ ์ค๋ณต๋ ๊ฐ ํ์ฉ (์ด์ง ํ์ ํธ๋ฆฌ๋ ์ค๋ณต๊ฐ ํ์ฉX)
# ํ ์ข ๋ฅ
# ์ต๋ ํ(max heap)
๋ถ๋ชจ ๋ ธ๋์ ํค ๊ฐ์ด ์์ ๋ ธ๋์ ํค ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ์์ ์ด์ง ํธ๋ฆฌ
# ์ต์ ํ(min heap)
๋ถ๋ชจ ๋ ธ๋์ ํค ๊ฐ์ด ์์ ๋ ธ๋์ ํค ๊ฐ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ด์ง ํธ๋ฆฌ
# ๊ตฌํ
ํ์ ์ ์ฅํ๋ ํ์ค์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐฐ์ด
๊ตฌํ์ ์ฝ๊ฒ ํ๊ธฐ ์ํด ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์ธ๋ฑ์ค์ธ 0์ ์ฌ์ฉ๋์ง ์์
ํน์ ์์น์ ๋ ธ๋ ๋ฒํธ๋ ์๋ก์ด ๋ ธ๋๊ฐ ์ถ๊ฐ๋์ด๋ ๋ณํ์ง ์์
(ex. ๋ฃจํธ ๋ ธ๋(1)์ ์ค๋ฅธ์ชฝ ๋ ธ๋ ๋ฒํธ๋ ํญ์ 3)
# ๋ถ๋ชจ ๋ ธ๋์ ์์ ๋ ธ๋ ๊ด๊ณ
์ผ์ชฝ ์์ index = (๋ถ๋ชจ index) * 2
์ค๋ฅธ์ชฝ ์์ index = (๋ถ๋ชจ index) * 2 + 1
๋ถ๋ชจ index = (์์ index) / 2
# ํ์ ์ฝ์
1.ํ์ ์๋ก์ด ์์๊ฐ ๋ค์ด์ค๋ฉด, ์ผ๋จ ์๋ก์ด ๋ ธ๋๋ฅผ ํ์ ๋ง์ง๋ง ๋ ธ๋์ ์ฝ์
2.์๋ก์ด ๋ ธ๋๋ฅผ ๋ถ๋ชจ ๋ ธ๋๋ค๊ณผ ๊ตํ
# ์ต๋ ํ ์ฝ์ ๊ตฌํ
void insert_max_heap(int x) {
maxHeap[++heapSize] = x;
// ํ ํฌ๊ธฐ๋ฅผ ํ๋ ์ฆ๊ฐํ๊ณ , ๋ง์ง๋ง ๋
ธ๋์ x๋ฅผ ๋ฃ์
for( int i = heapSize; i > 1; i /= 2) {
// ๋ง์ง๋ง ๋
ธ๋๊ฐ ์์ ์ ๋ถ๋ชจ ๋
ธ๋๋ณด๋ค ํฌ๋ฉด swap
if(maxHeap[i/2] < maxHeap[i]) {
swap(i/2, i);
} else {
break;
}
}
}
๋ถ๋ชจ ๋ ธ๋๋ ์์ ์ ์ธ๋ฑ์ค์ /2 ์ด๋ฏ๋ก, ๋น๊ตํ๊ณ ์์ ์ด ๋ ํฌ๋ฉด swapํ๋ ๋ฐฉ์
# ํ์ ์ญ์
1.์ต๋ ํ์์ ์ต๋๊ฐ์ ๋ฃจํธ ๋ ธ๋์ด๋ฏ๋ก ๋ฃจํธ ๋ ธ๋๊ฐ ์ญ์ ๋จ (์ต๋ ํ์์ ์ญ์ ์ฐ์ฐ์ ์ต๋๊ฐ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒ)
2.์ญ์ ๋ ๋ฃจํธ ๋ ธ๋์๋ ํ์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ์ ธ์ด
3.ํ์ ์ฌ๊ตฌ์ฑ
# ์ต๋ ํ ์ญ์ ๊ตฌํ
int delete_max_heap() {
if(heapSize == 0) // ๋ฐฐ์ด์ด ๋น์ด์์ผ๋ฉด ๋ฆฌํด
return 0;
int item = maxHeap[1]; // ๋ฃจํธ ๋
ธ๋์ ๊ฐ์ ์ ์ฅ
maxHeap[1] = maxHeap[heapSize]; // ๋ง์ง๋ง ๋
ธ๋ ๊ฐ์ ๋ฃจํธ๋ก ์ด๋
maxHeap[heapSize--] = 0; // ํ ํฌ๊ธฐ๋ฅผ ํ๋ ์ค์ด๊ณ ๋ง์ง๋ง ๋
ธ๋ 0 ์ด๊ธฐํ
for(int i = 1; i*2 <= heapSize;) {
// ๋ง์ง๋ง ๋
ธ๋๊ฐ ์ผ์ชฝ ๋
ธ๋์ ์ค๋ฅธ์ชฝ ๋
ธ๋๋ณด๋ค ํฌ๋ฉด ๋
if(maxHeap[i] > maxHeap[i*2] && maxHeap[i] > maxHeap[i*2+1]) {
break;
}
// ์ผ์ชฝ ๋
ธ๋๊ฐ ๋ ํฐ ๊ฒฝ์ฐ, swap
else if (maxHeap[i*2] > maxHeap[i*2+1]) {
swap(i, i*2);
i = i*2;
}
// ์ค๋ฅธ์ชฝ ๋
ธ๋๊ฐ ๋ ํฐ ๊ฒฝ์ฐ
else {
swap(i, i*2+1);
i = i*2+1;
}
}
return item;
}
# [์ฐธ๊ณ ์๋ฃ]
โ - ์คํ & ํ - ํธ๋ฆฌ(Tree) โ