์๋ ํ์ธ์ ์ฃผ์ธ์ฅ H์ ๋๋ค.
์ค๋์ ํ์ ๋ ฌ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
ํ์ ๋ ฌ์ ํํธ๋ฆฌ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ์ ๋ ฌ์ ํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
ํ์ ์ต์๊ฐ์ด๋ ์ต๋๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ์๋ด๊ธฐ ์ํด ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ํธ๋ฆฌ์ ๋๋ค.
์ฌ๊ธฐ์ ์์ ์ด์งํธ๋ฆฌ๋ ๋ถ๋ชจ๋ ธ๋(root)์ 2๊ฐ์ ์์๋ ธ๋(c)๋ฅผ ๊ฐ์ง ํํ๋ฅผ ๋งํฉ๋๋ค.
ํ์๋ ์ต๋ํ๊ณผ ์ต์ํฉ์ด ์กด์ฌํ๊ณ , ์ต๋ ํ์ ๋ถ๋ชจ๋ ธ๋๊ฐ ์์๋ ธ๋๋ณด๋ค ์ปค์ผํฉ๋๋ค.
ํ์ ๋ ฌ์ ํ๊ธฐ์ํด์ ์ ํด์ง ๋ฐ์ดํฐ๋ฅผ ํ๊ตฌ์กฐ๋ก ๋ง๋ ํ์ ์์ํด์ผ ํฉ๋๋ค.
ํ ์ ๋ ฌ์ ์ํํ๊ธฐ ์ํด์ ํ ์์ฑ ์๊ณ ๋ฆฌ์ฆ(heapifiy Algorithm)์ ์ฌ์ฉํฉ๋๋ค.
ํน์ ๋ ธ๋์ ๋ ์์ ์ค ๋ ํฐ ์์๊ณผ ์์ ์ ๋ฐ๊พธ๋ฉด ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด
1
4 9
2 3 4 4
9
4 4
2 3 4 1
๋ก ํ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ณ ํน์ ๋ ธ๋ 9์ 1์ ์๋ก ๋ฐ๊พธ์ด ์ค๋๋ค
1
4 4
2 3 4 9
๊ทธ ํ 9๋ฅผ ์ ์ธํ ๋ค๋ฅธ ๋ ธ๋๋ค์ ๋ค์ ์ต๋ํญ์ ๋ง๋ค์ด์ฃผ๋ ๊ฒ์ ๋ฐ๋ณตํ๋ฉด
2
3 2
4 4 4 9
์ ํํ๋ก ์ ๋ ฌ์ด ๋ ๊ฒ์ ๋๋ค.
๊ทธ๋ผ ์์์๋ถํฐ ์ฐจ๋ก๋๋ก ์ธ๋ฑ์ค์ ๋ฃ์ด์ฃผ๋ฉด ๋๊ฒ ์ฃ .
์ด๋ ํ์ ๋ ฌ์ ์ ์ฒด ์๊ฐ ๋ณต์ก๋๋
ํ์์ฑ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ๋ณต์ก๋๊ฐ O(log N)์ด๊ณ ์ ์ฒด ๋ฐ์ดํฐ์ ๊ฐฏ์๊ฐ N์ด๋ฏ๋ก
O(log N * N)์ด ๋๊ฒ ์ต๋๋ค.
#include <stdio.h>
#define HEAPSIZE 9
int heap[HEAPSIZE] = { 1,5,3,6,2,6,6,4,9 };
//ํ ๊ตฌ์กฐ ๋ง๋ค๊ธฐ
int main(void) {
for (int i = 1; i < HEAPSIZE; i++) {
int c = i;
do {
int root = (c - 1) / 2;
if (heap[root] < heap[c]) {
int temp = heap[root];
heap[root] = heap[c];
heap[c] = temp;
} c = root;
} while (c != 0);
}
//ํฌ๊ธฐ๋ฅผ ์ค์ฌ๊ฐ๋ฉฐ ํ ์ ๋ ฌ
for (int i = HEAPSIZE - 1; i >= 0; i--) {
int temp = heap[0];
heap[0] = heap[i];
heap[i] = temp;
int root = 0;
int c = 1;
//์์ ์ค์ ํฐ ๊ฐ์ด ์๋์ง ํ์ธ
do {
c = 2 * root + 1;
if (c < i - 1 && heap[c] < heap[c + 1]) {
c++;
}
//root ๊ฐ์ด ๋ ํฌ๋ค๋ฉด ๊ต์ฒด
if (c < i && heap[root] < heap[c]) {
temp = heap[c];
heap[c] = heap[root];
heap[root] = temp;
}
root = c;
} while (c < i);
}
for (int i = 0; i < HEAPSIZE; i++) {
printf("%d ", heap[i]);
}
return 0;
}
'์๋ฃ๊ตฌ์กฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C์ธ์ด] ๋ฐฐ์ด๋ก ๊ตฌํํ ๋ฆฌ์คํธ (0) | 2020.11.06 |
---|---|
[์๋ฃ๊ตฌ์กฐ] counting sort ๊ณ์์ ๋ ฌ (0) | 2020.08.18 |
[์๋ฃ๊ตฌ์กฐ] c++ sortํจ์๋ฅผ ํ์ฉํ ์ ๋ ฌ (0) | 2020.08.12 |
[์๋ฃ๊ตฌ์กฐ] ๋ณํฉ์ ๋ ฌ merge sort (0) | 2020.08.06 |
[์๋ฃ๊ตฌ์กฐ] ํต์ ๋ ฌ Quick Sort (0) | 2020.08.04 |