Heap
ํ(heap)์ ์ต๋๊ฐ ๋ฐ ์ต์๊ฐ์ ์ฐพ์๋ด๋ ์ฐ์ฐ์ ๋น ๋ฅด๊ฒ ํ๊ธฐ ์ํด ๊ณ ์๋ ์์ ์ด์งํธ๋ฆฌ(Complete binary tree)๋ฅผ ๊ธฐ๋ณธ์ผ๋ก ํ ์๋ฃ๊ตฌ์กฐ(tree-based structure)์ด๋ค. (์ํค๋ฐฑ๊ณผ )

์์ฉ
Graph Algorithm : Dijkstra, Prim's Minimum Spanning Tree(ํ๋ฆผ ์ต์ ์ ์ฅ ํธ๋ฆฌ)
๊ทธ๋ฆฌ๊ณ ๋ค์ํ ๋ฌธ์ ๋ฅผ ํธ๋๋ฐ์์ ์ฌ์ฉ๋๋ค.
๊ท์น

์ต์ ํ(min heap)
๋ถ๋ชจ๋
ธ๋์ ํค๊ฐ์ด ์์๋
ธ๋์ ํค๊ฐ๋ณด๋ค ํญ์ ์๊ฑฐ๋ ๊ฐ๋ค. key(๋ถ๋ชจ๋
ธ๋) < key(์์๋
ธ๋)
์ต๋ ํ(max heap)
๋ถ๋ชจ๋
ธ๋์ ํค๊ฐ์ด ์์๋
ธ๋์ ํค๊ฐ๋ณด๋ค ํญ์ ํฌ๊ฑฐ๋ ๊ฐ๋ค. key(๋ถ๋ชจ๋
ธ๋) > key(์์๋
ธ๋)
๋ฐ๋ผ์ ๋ฃจํธ๋ ธ๋์๋ ํญ์ ๊ฐ์ฅ ํฐ ๊ฐ์ด๋ ๊ฐ์ฅ ์์ ๊ฐ์ด ์ ์ฅ๋์ด ์๊ธฐ๋๋ฌธ์ ์ต๋๊ฐ ๋๋ ์ต์๊ฐ์ O(1)๋ง์ ์ฐพ์ ์ ์๋ค. ์ฌ๊ธฐ์ ํค๊ฐ์ ์ค๋ก์ง ๋ถ๋ชจ ์์๋ ธ๋๊ฐ์๋ง ์ฑ๋ฆฝํ๋ค.
Height/Depth
n๊ฐ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๊ณ ์๋ heap์ ๋์ด๋ O(logn)์ด๋ค. ํ์ ์์ ์ด์งํธ๋ฆฌ์ด๋ฏ๋ก ๋ ธ๋์ ๊ฐ์๋ก ๊น์ด์ ๋์ด๋ฅผ ๊ณ์ฐํ ์ ์๋ค.
๋ง์ง๋ง level์ ์ ์ธํ๊ณ ๋ ๊ฐ ๋ ๋ฒจ i์ 2^i๊ฐ์ ๋ ธ๋๊ฐ ์กด์ฌํ๋ค.
๊ตฌํ
๋ฐฐ์ด

ํ์ ์์ ์ด์งํธ๋ฆฌ์ด๋ฏ๋ก ๊ฐ ๋ ธ๋์ ๋ฒํธ๋ฅผ ๋ถ์ผ ์ ์๋ค. ๋ฐฐ์ด์ ์์ ์ด์งํธ๋ฆฌ๋ฅผ ํํํ๊ธฐ์ ๋งค์ฐ ํจ์จ์ ์ด๋ค.
๋ฐฐ์ด๋ก ํํํจ์ผ๋ก์จ ๋ถ๋ชจ๋ ธ๋์ ์์๋ ธ๋๋ฅผ ์ฐพ๊ธฐ๊ฐ ์ฌ์์ง๋ค.
์ผ์ชฝ ์์๋ ธ๋ ์ธ๋ฑ์ค :
2*(๋ถ๋ชจ๋ ธ๋ ์ธ๋ฑ์ค)
์ค๋ฅธ์ชฝ ์์๋ ธ๋
2*(๋ถ๋ชจ๋ ธ๋ ์ธ๋ฑ์ค)+1
๋ ธ๋ x์ ๋ถ๋ชจ ๋ ธ๋ ์ธ๋ฑ์ค๋
(์์๋ ธ๋ ์ธ๋ฑ์ค)/2
๋ก ์ ์ ์๋ค.
์ฃผ์์ฌํญ index๋ 1๋ถํฐ ์์!ํ๋ค๋ ์ ์ ์ฃผ์ํด์ผํ๋ค.
์ฝ์
(upheap)

๊ฐ์ฅ ๋์ ์๋ฆฌ์ ๋ ธ๋๋ฅผ ์ฝ์ ํ๋ค.
๊ทธ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์๋ก ๋น๊ตํ๋ค.
๊ท์น(์ต์ํ, ์ต๋ํ)์ ๋ง์ผ๋ฉด ๊ทธ๋๋ก ๋๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ๋ถ๋ชจ์ ๊ตํํ๋ค.
๊ท์น์ ๋ง์ ๋๊น์ง 1~3๋ฒ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค.
์๊ฐ๋ณต์ก๋
O(logn)
์ญ์ (downheap)

์ต๋๊ฐ ํน์ ์ต์๊ฐ์ด ์ ์ฅ๋ ๋ฃจํธ ๋ ธ๋๋ง ์ ๊ฑฐํ ์ ์๋ค.
๋ฃจํธ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ค.
๋ฃจํธ ์๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ฝ์ ํ๋ค.
์ฌ๋ผ๊ฐ ๋ ธ๋์ ๊ทธ์ ์์ ๋ ธ๋(๋ค)์ ๋น๊ตํ๋ค.
์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ๊ทธ๋๋ก ๋๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ์์๊ณผ ๊ตํํ๋ค.
์ต๋ ํ 1. ๋ถ๋ชจ๋ณด๋ค ๋ ํฐ ์์์ด ์์ผ๋ฉด ๊ตํํ์ง ์๊ณ ๋๋ธ๋ค. 2. ๋ถ๋ชจ๋ณด๋ค ๋ ํฐ ์์์ด ํ๋๋ง ์์ผ๋ฉด ๊ทธ ์์ํ๊ณ ๊ตํํ๋ฉด ๋๋ค. 3. ๋ถ๋ชจ๋ณด๋ค ๋ ํฐ ์์์ด ๋ ์์ผ๋ฉด ์์๋ค ์ค ํฐ ๊ฐ๊ณผ ๊ตํํ๋ค.
์ต์ ํ 1. ๋ถ๋ชจ๋ณด๋ค ๋ ์์ ์์์ด ์์ผ๋ฉด ๊ตํํ์ง ์๊ณ ๋๋ธ๋ค. 2. ๋ถ๋ชจ๋ณด๋ค ๋ ์์ ์์์ด ํ๋๋ง ์์ผ๋ฉด ๊ทธ ์์ํ๊ณ ๊ตํํ๋ฉด ๋๋ค. 3. ๋ถ๋ชจ๋ณด๋ค ๋ ์์ ์์์ด ๋ ์์ผ๋ฉด ์์๋ค ์ค ์์ ๊ฐ๊ณผ ๊ตํํ๋ค.
์กฐ๊ฑด์ ๋ง์กฑํ ๋๊น์ง 4์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค.
์๊ฐ๋ณต์ก๋
O(logn)
๊ตฌํ
์ต์ํ
#include <stdio.h>
#define MAX 1000000
typedef struct{
int heap[MAX];
int hsize;
}Heap;
void init(Heap * h){
h->hsize=0;
}
void insert(Heap * h, int key){
int p; //ํ์ฌ ์์น ์ ์ฅ
// ๋ง์ง๋ง ์์น์ ์ถ๊ฐ
h->heap[++(h->hsize)]=key;
// ์์น ์กฐ์
p=h->hsize;
while((h->heap[p/2])>key){
h->heap[p] = h->heap[p/2];
p/=2;
}
h->heap[p]=key;
}
int delete(Heap * h){
int min,last,child,i;
//๋ฃจํธ๋
ธ๋๊ฐ์ด ์ต์
min = h->heap[1];
last = h->heap[(h->hsize)--];
for(i=1; i*2<=h->hsize; i=child){
child = i*2;
if(child!=h->hsize && h->heap[child+1]<h->heap[child])child++;
if(last>h->heap[child])h->heap[i]=h->heap[child];
else break;
}
h->heap[i]=last;
return min;
}
int main(int argc, const char * argv[]) {
Heap heap;
int min;
init(&heap);
insert(&heap, 10);
insert(&heap, 5);
insert(&heap, 30);
for(int i=1;i<=heap.hsize;i++){
printf("%d ",heap.heap[i]);
}
min = delete(&heap);
printf("\n%d \n",min);
for(int i=1;i<=heap.hsize;i++){
printf("%d ",heap.heap[i]);
}
min = delete(&heap);
printf("\n%d \n",min);
for(int i=1;i<=heap.hsize;i++){
printf("%d ",heap.heap[i]);
}
return 0;
}
์ต๋ํ
#include <stdio.h>
#define MAX 100
typedef struct{
int heap[MAX];
int hsize;
}Heap;
void init(Heap * h){
h->hsize=0;
}
void insert_max(Heap * h, int key){
int p; //ํ์ฌ ์์น ์ ์ฅ
p=++(h->hsize);
// ๋ง์ง๋ง ์์น์ ์ถ๊ฐ
h->heap[p]=key;
// ์์น ์กฐ์
while((h->heap[p/2])<key){
if(p==1)break;
h->heap[p] = h->heap[p/2];
p/=2;
}
h->heap[p]=key;
}
int delete_max(Heap * h){
int max,last,child,i;
//๋ฃจํธ๋
ธ๋๊ฐ์ด ์ต์
max = h->heap[1];
last = h->heap[(h->hsize)--];
for(i=1; i*2<=h->hsize; i=child){
child = i*2;
if(child!=h->hsize && h->heap[child+1]>h->heap[child])child++;
if(last<h->heap[child])h->heap[i]=h->heap[child];
else break;
}
h->heap[i]=last;
return max;
}
int main(int argc, const char * argv[]) {
Heap heap;
int max;
init(&heap);
insert_max(&heap, 10);
insert_max(&heap, 5);
insert_max(&heap, 30);
for(int i=1;i<=heap.hsize;i++){
printf("%d ",heap.heap[i]);
}
max = delete_max(&heap);
printf("\n%d \n",max);
for(int i=1;i<=heap.hsize;i++){
printf("%d ",heap.heap[i]);
}
max = delete_max(&heap);
printf("\n%d \n",max);
for(int i=1;i<=heap.hsize;i++){
printf("%d ",heap.heap[i]);
}
return 0;
}
Last updated
Was this helpful?