Heap एक complete binary tree है जहाँ हर parent heap property satisfy करता है - या तो हमेशा छोटा (min-heap) या हमेशा बड़ा (max-heap) अपने children से। "Complete" का मतलब हर level भरा है, सिवाय शायद last level के जो left से right भरता है।
1 Min-heap
/ \
3 5
/ \
7 4
Complete होने की वजह से इसे flat array में store करते हैं - pointers की ज़रूरत नहीं। Index i के लिए: left child = 2i + 1, right child = 2i + 2, parent = (i - 1) // 2।
| Property | Min-Heap | Max-Heap | |----------|----------|----------| | Root | सबसे छोटा element | सबसे बड़ा element | | Parent ≤ Children? | ✅ हाँ | ❌ नहीं (≥) | | Extract देता है | Minimum | Maximum |
Python का heapq default में min-heap है। Max-heap के लिए insert पर values negate करो और extract पर वापस negate करो।
Insert - end पर push करो, फिर bubble up (parent से swap करो जब तक छोटा हो):
import heapq
h = [1, 3, 5, 7]
heapq.heappush(h, 2) # h becomes [1, 2, 5, 7, 3]
Extract min - root को last element से swap करो, last pop करो, फिर sift down (smaller child से swap):
smallest = heapq.heappop(h) # returns 1
दोनों operations O(log n) में चलते हैं क्योंकि tree की height log n है।
heapq.heapify(arr) एक list को O(n) में heap बना देता है, O(n log n) नहीं। यह bottom-up काम करता है, हर non-leaf node को sift down करता है।
Sign in to join the discussion
Priority queue हमेशा highest-priority item पहले access करने देता है। Heaps इसका best implementation हैं क्योंकि insert और extract दोनों O(log n) हैं। जब भी "अब तक का best item दो" चाहिए, priority queue इस्तेमाल करो।
"Unsorted array में K largest elements ढूँढो।"
Size K का min-heap रखो। हर element push करो; अगर heap K से बड़ा हो जाए, smallest pop करो। जो बचे वो K largest हैं।
import heapq
def top_k(nums, k):
return heapq.nlargest(k, nums)
Time: O(n log k) - जब k ≪ n हो तो sorting से काफ़ी बेहतर।
10 लाख entries में से 5 सबसे बड़े scores चाहिए। कौन सा heap type और size?
हर list का head min-heap में push करो। Smallest pop करो, फिर उसी list का next element push करो। जब तक सब lists खत्म न हो जाएँ। Time: O(N log K) जहाँ N total elements हैं।
दो heaps maintain करो: lower half के लिए max-heap और upper half के लिए min-heap। Sizes में maximum 1 का difference रखो। Median हमेशा एक या दोनों roots पर होता है।
Lower half (max-heap): [1, 2, 3] ← max = 3
Upper half (min-heap): [4, 5, 6] ← min = 4
Median = (3 + 4) / 2 = 3.5
Two-heap median approach में नया element पहले कहाँ जाता है?
Heaps scheduling में कमाल करते हैं: meeting rooms (earliest end-time track करो), task scheduling with cooldowns, या CPU job queues। मूल बात: heap efficiently track करता है "अगला क्या खत्म होगा।"
| ज़रूरत | Best choice | क्यों | |--------|-------------|-------| | बार-बार min/max extract | Heap | O(log n) insert + extract | | Static data, एक बार sort | Sorted array | O(n log n) एक बार, O(1) access | | Range queries + order stats | Balanced BST | O(log n) हर चीज़ के लिए | | Stream से Top-K | Size K का Heap | O(n log k) total |
Min-heap में कौन सा operation O(1) है?
| Operation | Time | |-----------|------| | Insert | O(log n) | | Extract min/max | O(log n) | | Peek min/max | O(1) | | Heapify | O(n) | | n items से Top-K | O(n log k) |