- ๊ฐ์
- ๊ฐ๋
ํ์ ์๋ฃ๊ตฌ์กฐ์ ์ผ์ข ์ผ๋ก ์ฐ์ ์์ ํ๋ฅผ ์ํด์ ๋ง๋ค์ด์ก๋ค.
-
์ฐ์ ์์ ํ : ์ฐ์ ์์์ ๊ฐ๋ ์ ํ์ ๋์ ํ ์๋ฃ๊ตฌ์กฐ.
- ๋ฐ์ดํฐ๋ค์ด ์ฐ์ ์์๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ์ฐ์ ์์๊ฐ ๋์ ๋ฐ์ดํฐ๊ฐ ํ์์ ๋จผ์ ๋น ์ ธ ๋๊ฐ๋ค.
-
์ธ์ ์ฌ์ฉ?
- ์๋ฎฌ๋ ์ด์ ์์คํ , ์์ ์ค์ผ์ค๋ง, ์์นํด์ ๊ณ์ฐ.
- ์ฐ์ ์์ ํ๋ ๋ฐฐ์ด, ์ฐ๊ฒฐ ๋ฆฌ์คํธ, ํ์ผ๋ก ๊ตฌํํ๋ค. (ํ์ผ๋ก ๊ตฌํํ๋ ๊ฒ ๊ฐ์ฅ ํจ์จ์ ์ด๋ค.)
-
์๊ฐ ๋ณต์ก๋
- ์ฝ์ : O(logN)
- ์ญ์ : O(logN)
-
์คํ : LIFO, ํ : FIFO
- Tree์ ํ์์ ์ทจํ๊ณ ์์ผ๋ฉฐ Tree ์ค์์๋ ๋ฐฐ์ด์ ๊ธฐ๋ฐ์ผ๋ก ํ (Complete Binary Tree)์์ ์ด์ง ํธ๋ฆฌ์ด๋ค.
- ์ต๋๊ฐ ๋ฐ ์ต์๊ฐ์ ์ฐพ์๋ด๋ ์ฐ์ฐ์ ๋น ๋ฅด๊ฒ ํ๊ธฐ ์ํด ๊ณ ์๋ ์์ ์ด์ง ํธ๋ฆฌ์ด๋ค.
- ๋ฐฐ์ด์ ํธ๋ฆฌ์ ๊ฐ์ ๋ฃ์ด์ค ๋๋ 0๋ฒ์งธ๋ ๊ฑด๋๋ฐ๊ณ 1๋ฒ์งธ๋ถํฐ ๋ฃจํธ ๋ ธ๋๊ฐ ์์๋๋ค. ์ด์ ๋ ๋ ธ๋์ ๊ณ ์ ๋ฒํธ์ index๋ฅผ ์ผ์น์์ผ ํผ๋์ ์ค์ด๊ธฐ ์ํจ์ด๋ค.
- ์ค๋ณต๋ ๊ฐ์ ํ์ฉ. (์ด์ง ํ์ ํธ๋ฆฌ๋ ์ค๋ณต ๊ฐ์ ํ์ฉํ์ง ์์.)
- ํ์ ์ข
๋ฅ๋ก๋ ์ต๋ํ๊ณผ ์ต์ํ์ด ์กด์ฌํ๋ค.
- ์ต๋ํ : ๊ฐ ๋ ธ๋์ ๊ฐ์ด ์์ ๋ ธ๋์ ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ Complete Binary Tree๋ฅผ ๋งํ๋ค.
- ์ต์ํ์ ์ต๋ํ์ ๋ฐ๋์ด๋ค.
- ์ต๋ํ์์๋ Root Node์ ์๋ ๊ฐ์ด ์ ์ผ ํฌ๋ฏ๋ก, ์ต๋๊ฐ์ ์ฐพ๋๋ฐ ์์๋๋ ์ฐ์ฐ์ ์๊ฐ ๋ณต์ก๋๋ O(1)์ด๋ค.
- Complete Binary Tree์ด๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ์ด์ฉํด ๊ด๋ฆฌํ ์ ์์ผ๋ฉฐ, ์ธ๋ฑ์ค๋ฅผ ํตํ Random Access๊ฐ ๊ฐ๋ฅํ๋ค.
- Index ๋ฒํธ๋ ๋ ธ๋ ๊ฐ์๊ฐ n๊ฐ์ผ ๋, i๋ฒ์งธ ๋ ธ๋์ ๋ํ์ฌ ์ผ์ชฝ ์์์ ix2, ์ค๋ฅธ์ชฝ ์์์ ix2+1๊ฐ ๋๋ค.
ํ์ ์ ์ฅํ๋ ํ์ค์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐฐ์ด์ด๋ค.
๊ตฌํ์ ์ฝ๊ฒ ํ๊ธฐ ์ํด ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค์ธ 0์ ์ฌ์ฉ๋์ง ์๊ณ , 1๋ถํฐ ์์ํ๋ค.
ํน์ ์์น์ ๋ ธ๋ ๋ฒํธ๋ ์๋ก์ด ๋ ธ๋๊ฐ ์ถ๊ฐ๋์ด๋ ๋ณํ์ง ์๋๋ค.
<๋ถ๋ชจ ๋ ธ๋์ ์์ ๋ ธ๋์ ๊ด๊ณ>
- ์ผ์ชฝ ์์ index : (๋ถ๋ชจ index) * 2
- ์ค๋ฅธ์ชฝ ์์ index : (๋ถ๋ชจ index) * 2 + 1
- ๋ถ๋ชจ index : (์์ index) / 2
- <ํ์ ์ฝ์ >
- ํ์ ์๋ก์ด ์์๊ฐ ๋ค์ด์ค๋ฉด, ์ผ๋จ ์๋ก์ด ๋ ธ๋๋ฅผ ํ์ ๋ง์ง๋ง ๋ ธ๋์ ์ฝ์ .
- ์๋ก์ด ๋ ธ๋๋ฅผ ๊ฒ์ฌํด์ ๋ถ๋ชจ ๋ ธ๋์ ๊ตํํ๋ค.
[์ต๋ ํ ์ฝ์ ๊ตฌํ]
void insert_max_heap(int x){
maxHeap[++heapSize] = x;
// ํ ํฌ๊ธฐ๋ฅผ ํ๋ ์ฆ๊ฐ์ํค๊ณ , ๋ง์ง๋ง ๋
ธ๋์ x๋ฅผ ์ฝ์
.
for(int i=heapSize; i>1; i--){
// ๋ง์ง๋ง ๋
ธ๋๊ฐ ์์ ์ ๋ถ๋ชจ ๋
ธ๋๋ณด๋ค ํฌ๋ฉด swap
if(maxHeap[i / 2] < maxHeap[i]){
swap(i / 2, i);
} else {
break
}
}
}
๋ถ๋ชจ ๋ ธ๋ : ์์ ์ ์ธ๋ฑ์ค / 2 ์ด๋ฏ๋ก ๋ง์ง๋ง ๋ ธ๋์ ๋น๊ตํ์ฌ ๋ง์ง๋ง ๋ ธ๋๊ฐ ๋ ํฌ๋ฉด ์์น๋ฅผ ๋ฐ๊ฟ์ค๋ค.
- <ํ์ ์ญ์ >
- ์ต๋ ํ์์ ์ต๋๊ฐ์ ๋ฃจํธ ๋ ธ๋์ด๋ฏ๋ก ๋ฃจํธ ๋ ธ๋๊ฐ ์ญ์ ๋๋ค. (์ต๋ ํ์์ ์ญ์ ์ฐ์ฐ์ ์ต๋๊ฐ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒ์ด๋ค.)
- ์ญ์ ๋ ๋ฃจํธ ๋ ธ๋์์๋ ํ์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ์ ธ์จ๋ค.
- ํ์ ์ฌ๊ตฌ์ฑ ํ๋ค.
[์ต๋ ํ ์ญ์ ๊ตฌํ]
int delete_map_heap(){
if(heapSize == 0) return 0; // ๋น์ด์์์ ์๋ฏธํ๋ฏ๋ก ๋ฆฌํด.
int root = 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;
// ์ค๋ฅธ์ชฝ ๋
ธ๋๊ฐ ๋ ํฐ ๊ฒฝ์ฐ, swap
} else {
swap(i, i * 2 + 1);
i = i * 2 + 1;
}
}
return root;
}
- ๋ ๊ฐ์ ์๋ธ ํธ๋ฆฌ๊ฐ ์ต๋ํ(์ต์ํ)์ผ ๋, root๋ฅผ ํฌํจํ๋ ์ ์ฒด๊ฐ heap์ด ๋๋๋ก ์์น๋ฅผ ์กฐ์ ํ๋ ๊ณผ์ ์ ๋งํ๋ค.
- ๋ฃจํธ์์ ์์ ๊ฐ์ด ํ๋ฌ ๋ด๋ ค๊ฐ๋ฉด์ ์ฒ๋ฆฌ๋๋ ๋ฐฉ์์ผ๋ก ์งํ๋๋ค. ์ต๋ํ์ ๊ฒฝ์ฐ root๊ฐ child๋ณด๋ค ์์ผ๋ฉด ๋ ๊ฐ์ child node ์ค ๊ฐ์ด ํฐ ๋ ธ๋๋ฅผ root์ ๊ต์ฒดํ๊ณ ๊ต์ฒดํ ๋ ธ๋๊ฐ ์์ ๋๊น์ง ๋ฐ๋ณตํ๋ค.