AI EducademyAIEducademy
🌳

AI की नींव

🌱
AI Seeds

शून्य से शुरू करें

🌿
AI Sprouts

नींव बनाएं

🌳
AI Branches

व्यवहार में लागू करें

🏕️
AI Canopy

गहराई में जाएं

🌲
AI Forest

AI में महारत हासिल करें

🔨

AI में महारत

✏️
AI Sketch

शून्य से शुरू करें

🪨
AI Chisel

नींव बनाएं

⚒️
AI Craft

व्यवहार में लागू करें

💎
AI Polish

गहराई में जाएं

🏆
AI Masterpiece

AI में महारत हासिल करें

🚀

करियर रेडी

🚀
इंटरव्यू लॉन्चपैड

अपनी यात्रा शुरू करें

🌟
व्यवहारिक इंटरव्यू में महारत

सॉफ्ट स्किल्स में महारत

💻
तकनीकी इंटरव्यू

कोडिंग राउंड में सफल हों

🤖
AI और ML इंटरव्यू

ML इंटरव्यू में महारत

🏆
ऑफर और उससे आगे

सबसे अच्छा ऑफर पाएं

सभी कार्यक्रम देखें→

लैब

7 प्रयोग लोड हुए
🧠न्यूरल नेटवर्क प्लेग्राउंड🤖AI या इंसान?💬प्रॉम्प्ट लैब🎨इमेज जनरेटर😊सेंटिमेंट एनालाइज़र💡चैटबॉट बिल्डर⚖️एथिक्स सिमुलेटर
🎯मॉक इंटरव्यूलैब में जाएँ→
nav.journeyब्लॉग
🎯
हमारे बारे में

हर जगह, हर किसी के लिए AI शिक्षा सुलभ बनाना

❓
nav.faq

Common questions answered

✉️
Contact

Get in touch with us

⭐
ओपन सोर्स

GitHub पर सार्वजनिक रूप से निर्मित

सीखना शुरू करें - यह मुफ्त है
AI EducademyAIEducademy

MIT लाइसेंस - ओपन सोर्स

सीखें

  • कार्यक्रम
  • पाठ
  • लैब

समुदाय

  • GitHub
  • योगदान करें
  • आचार संहिता
  • हमारे बारे में
  • सामान्य प्रश्न

सहायता

  • कॉफ़ी खरीदें ☕
  • footer.terms
  • footer.privacy
  • footer.contact
AI और इंजीनियरिंग प्रोग्राम›✏️ AI Sketch›पाठ›Heaps और Priority Queues
⛰️
AI Sketch • मध्यम⏱️ 18 मिनट पढ़ने का समय

Heaps और Priority Queues

Heap क्या है?

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।

Min-Heap vs Max-Heap

| 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 और Extract - Step by Step

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 है।

Min-heap पर insert bubble-up और extract sift-down दिखाने वाला diagram
Insert bubble up करता है; extract-min sift down करता है।

Heapify - O(n) में Heap बनाओ

heapq.heapify(arr) एक list को O(n) में heap बना देता है, O(n log n) नहीं। यह bottom-up काम करता है, हर non-leaf node को sift down करता है।

पाठ 6 / 100% पूर्ण
←Trees और Graphs Visualised

Discussion

Sign in to join the discussion

lessons.suggestEdit
in-place
🤯
Heap बनाना O(n) है, O(n log n) नहीं। ज़्यादातर nodes bottom के पास हैं और बमुश्किल sift down करने पड़ते हैं - maths linear time पर settle करता है।

Priority Queue Abstraction

Priority queue हमेशा highest-priority item पहले access करने देता है। Heaps इसका best implementation हैं क्योंकि insert और extract दोनों O(log n) हैं। जब भी "अब तक का best item दो" चाहिए, priority queue इस्तेमाल करो।

Pattern: Top-K Problems

"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?

Pattern: Merge K Sorted Lists

हर list का head min-heap में push करो। Smallest pop करो, फिर उसी list का next element push करो। जब तक सब lists खत्म न हो जाएँ। Time: O(N log K) जहाँ N total elements हैं।

Pattern: Median from Data Stream

दो 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 पहले कहाँ जाता है?

Scheduling Problems

Heaps scheduling में कमाल करते हैं: meeting rooms (earliest end-time track करो), task scheduling with cooldowns, या CPU job queues। मूल बात: heap efficiently track करता है "अगला क्या खत्म होगा।"

🤔
Think about it:अगर minimum और maximum दोनों efficiently चाहिए, तो एक heap काफ़ी नहीं। कौन सा data structure combination इस्तेमाल करोगे?

Heap vs Sorted Array vs BST

| ज़रूरत | 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) है?

Complexity Cheat Sheet

| 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) |

🤔
Think about it:Heap array में store होने के बावजूद binary search क्यों नहीं कर सकते? सोचो heap property actually कौन सा sorted order guarantee करती है।

📚 और पढ़ें

  • NeetCode - Heap / Priority Queue - visual problem roadmap
  • Tech Interview Handbook - Heap - concise patterns और tips
  • Python heapq docs - official module reference