Heap
Heap์ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
ย ์ฐ์ ์์ ํ (Priority Queue)
โข
์ฐ์ ์์ ํ๋ FIFO์ธ ์ผ๋ฐ ํ์ ๋ฌ๋ฆฌ ์ฐ์ ์์๊ฐ ๋์ ์์๊ฐ ๋จผ์ ๋๊ฐ๋ ์ถ์์๋ฃํ์ด๋ค.
โข
์ผ๋ฐ์ ์ผ๋ก ๋ฐฐ์ด, ์ฐ๊ฒฐ๋ฆฌ์คํธ, ํ ๋ฑ์ผ๋ก ๊ตฌํํ๋ค.
*์ถ์์๋ฃํ(Abstract Data Type, ADT)์ ๊ตฌํ ๋ฐฉ๋ฒ์ ๋ช
์ํ์ง ์๊ณ , ์๋ฃ๊ตฌ์กฐ์ ํน์ฑ๊ณผ ์ฐ์ฐ์ ๋ช
์ํ ๊ฒ์ด๋ค. Stack๊ณผ Queue ๋ฑ์ด ํด๋นํ๋ค.
์ฐ์ ์์ ํ๋ ์ผ๋ฐ์ ์ผ๋ก ์๋์ ์ฐ์ฐ์ ์ง์ํ๋ค.
โข
enqueue() : ์ ์์ ์ฝ์
โข
dequeue() : ๋ฃจํธ์ ์์๋ฅผ ์ญ์ ํ์ฌ ๊ทธ ๊ฐ์ ๋ฐํ
โข
peek() : ๋ฃจํธ ์์๋ฅผ ๋ฐํ
๊ตฌํ ๋ฐฉ์์ ๋ฐ๋ฅธ ์๊ฐ๋ณต์ก๋๋ ์๋์ ๊ฐ๋ค.
์๋ฃ๊ตฌ์กฐ | enqueue() | dequeue() |
๋ฐฐ์ด (unsorted array) | O(1) | O(N) |
์ฐ๊ฒฐ ๋ฆฌ์คํธ (unsorted linked list) | O(1) | O(N) |
์ ๋ ฌ๋ ๋ฐฐ์ด (sorted array) | O(N) | O(1) |
์ ๋ ฌ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ (sorted linked list) | O(N) | O(1) |
ํ (heap) | O(logN) | O(logN) |
ย ํ (Heap)
โข
ํ์ ์ด์งํธ๋ฆฌ ํํ๋ฅผ ๊ฐ์ง๋ฉฐ, ์ฐ์ ์์๊ฐ ๋์ ์์๋ฅผ ๋ฃจํธ๋ก ๋ฐฐ์นํ๊ณ ํญ์ ๋ฃจํธ๊ฐ ๋จผ์ ๋๊ฐ๋ค.
โข
์ฐ์ ์์๊ฐ ๋์ ์์๊ฐ ๋จผ์ ๋๊ฐ๊ธฐ ์ํด ์์๊ฐ ์ฝ์
๋ฐ ์ญ์ ๋๋ ์์ ์ ๋ฐ๋ก ์ ๋ ฌ๋๋ค.
โข
๋ฃจํธ๊ฐ ๊ฐ์ฅ ํฐ ๊ฐ์ด ๋๋ ์ต๋ ํ(Max Heap)๊ณผ ๋ฃจํธ๊ฐ ๊ฐ์ฅ ์์ ๊ฐ์ด ๋๋ ์ต์ ํ(Min Heap)์ด ์๋ค.
ย ํ ์์ ์ถ๊ฐ push()
1.
์ถ๊ฐํ ์์๋ฅผ ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ์ ์ ์ ์
๋ ฅํ๋ค.
2.
์ถ๊ฐํ ์์๊ฐ ๋ถ๋ชจ ์์๋ณด๋ค ์ฐ์ ์์๊ฐ ๋๋ค๋ฉด ๋ถ๋ชจ์ ์์๋ฅผ ๋ฐ๊พผ๋ค.
3.
์ด๋ฅผ ๋ฐ๋ณตํ๋ฉด ๊ฐ์ฅ ์ฐ์ ์์๊ฐ ๋์ ์์๊ฐ ๋ฃจํธ๊ฐ ๋๋ค.
โ ์์๊ฐ ํญ์ ๋ง์ง๋ง ์ ์ ์ ์ถ๊ฐ๋๊ธฐ ๋๋ฌธ์, ํ์ ํญ์ ์์ ์ด์งํธ๋ฆฌ์ด๋ฉฐ, ์์ ์ด์งํธ๋ฆฌ์ ๋์ด๋ log N ์ด๋ฏ๋ก ํ์ ์์ ์ถ๊ฐ ์๊ณ ๋ฆฌ์ฆ์ O(log N) ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค.
ย ํ ์์ ์ ๊ฑฐ pop()
1.
๋ฃจํธ ์ ์ ์ ์์๋ฅผ ์ ๊ฑฐํ๋ค.
2.
๊ฐ์ฅ ๋ง์ง๋ง ์ ์ ์ ์์๋ฅผ ๋ฃจํธ๋ก ์ฎ๊ธด๋ค.
3.
๋ฃจํธ ์์์ ๋ ์์ ์ค ์ฐ์ ์์๊ฐ ๋ ๋์ ์ ์ ๊ณผ ๋ฐ๊พผ๋ค.
4.
๋ ์์ ์์์ ์ฐ์ ์์๊ฐ ๋ ๋ฎ์ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
โ ํ์ ์์ ์ ๊ฑฐ ์๊ณ ๋ฆฌ์ฆ์ ์ถ๊ฐ์ ๋์ผํ๊ฒ O(log N) ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
ย Heap์ ์์ฉ
ํ์ ์ต๋ ์ต์ ๊ฐ์ ๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํ๋ ๊ฒฝ์ฐ, Dijkstra ์ ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ, ์ต์ ์ ์ฅ ํธ๋ฆฌ์ Prim ์๊ณ ๋ฆฌ์ฆ ๋ฑ์ ๊ทธ๋ํ ์๊ณ ๋ฆฌ์ฆ์์ ์ ์ฉํ๋ค.
๋ํ Heapsort ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ๊ณผ Huffman ์ฝ๋ฉ(๋ฐ์ดํฐ ์์ถ ๊ธฐ์ )์๋ ์ฌ์ฉ๋๋ค.
ย Heap ๊ตฌํ
์ด์ง ํธ๋ฆฌ ํํ๋ก ๊ตฌํํด๋ ๋๊ณ , ๋ฐฐ์ด๋ก ์ ์ฅํด๋ ๋๋ค.
ํ์ด์ฌ์์๋ heapq ๋ชจ๋์ ํตํด heap ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋ค.
heapq ๋ชจ๋์ ์ต์ํ์ผ๋ก ๊ตฌํ๋์ด ์๊ธฐ ๋๋ฌธ์, ์ต๋ ํ์ ์ฌ์ฉํ๋ ค๋ฉด ๋ณํ์ด ํ์ํ๋ค. (y = -x ๋ณํ)
import heapq
heap = []
heapq.heappush(heap, 50)
heapq.heappush(heap, 10)
heapq.heappush(heap, 20)
result = heapq.heappop(heap)
Python
๋ณต์ฌ
ย ์๋ฐ์คํฌ๋ฆฝํธ ์์๋ ์ง์ ๊ตฌํํ์ฌ ์ฌ์ฉ
class MaxHeap {
constructor() {
this.heap = [null];
}
swap(a, b) {
[this.heap[a], this.heap[b]] = [this.heap[b], this.heap[a]];
}
push(value) {
this.heap.push(value);
let currentIndex = this.heap.length-1;
let parentIndex = Math.floor(currentIndex / 2);
while (parentIndex !== 0 && this.heap[parentIndex] < value) {
swap(currentIndex, parentIndex);
currentIndex = parentIndex;
parentIndex = Math.floor(currentIndex / 2);
}
}
pop() {
const returnValue = this.heap[1];
this.heap[1] = this.heap.pop();
let currentIndex = 1;
let leftIndex = 2;
let rightIndex = 3;
while (
this.heap[currentIndex] < this.heap[leftIndex] ||
this.heap[currentIndex] < this.heap[rightIndex]
) {
if (this.heap[leftIndex] < this.heap[rightIndex]) {
swap(currentIndex, rightIndex);
currentIndex = rightIndex;
}
else {
swap(currentIndex, leftIndex);
currentIndex = leftIndex;
}
leftIndex = currentIndex * 2;
rightIndex = currentIndex * 2 + 1;
}
}
}
JavaScript
๋ณต์ฌ