Kth Smallest Element Using Min Heap in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Min Heap?

A Min Heap is a special tree-based data structure where the parent node is always smaller than or equal to its child nodes. This means the smallest element is always at the root.

beginner

How does a Min Heap help find the kth smallest element?

By building a Min Heap from the array, the smallest element is at the root. Removing the root k-1 times and then looking at the root gives the kth smallest element.

intermediate

What is the time complexity of finding the kth smallest element using a Min Heap?

Building the Min Heap takes O(n) time. Removing the root k times takes O(k log n) time. So overall, it is O(n + k log n).

beginner

What operation is used to remove the smallest element from a Min Heap?

The operation is called 'extractMin'. It removes the root (smallest element) and then re-adjusts the heap to maintain the Min Heap property.

intermediate

Why is a Min Heap preferred over sorting the entire array to find the kth smallest element?

Using a Min Heap can be more efficient because it avoids sorting the entire array, especially when k is small compared to n. It focuses only on extracting the smallest elements needed.

What is the root of a Min Heap?

A Any random element

B The largest element

C The middle element

D The smallest element

In a Min Heap, the root is always the smallest element.

Which operation removes the smallest element from a Min Heap?

A insert

B extractMin

C heapify

D deleteMax

extractMin removes the root, which is the smallest element in a Min Heap.

What is the time complexity to build a Min Heap from an array of size n?

A O(n)

B O(k log n)

C O(log n)

D O(n log n)

Building a Min Heap from an array takes O(n) time.

To find the 3rd smallest element using a Min Heap, how many times do you extract the minimum?

A 1

B 3

C 2

D 4

You extract the minimum k-1 times (2 times for k=3), then the root is the kth smallest.

Why might using a Min Heap be better than sorting the whole array to find the kth smallest element?

A Min Heap only extracts needed elements, saving time

B Min Heap sorts the entire array faster

C Sorting is always slower

D Min Heap uses less memory

Min Heap focuses on extracting the smallest elements needed, which can be faster than sorting the entire array.

Explain step-by-step how to find the kth smallest element using a Min Heap.

Think about how the smallest elements come out first in a Min Heap.

Describe the advantages of using a Min Heap over sorting the entire array for finding the kth smallest element.

Consider time saved by partial extraction instead of full sorting.

Practice

1. What does the Kth Smallest Element Using Min Heap algorithm primarily do?

easy

A. Find the element that is the Kth smallest in a list using a min heap

B. Sort the entire list in ascending order

C. Find the largest element in the list

D. Remove duplicates from the list

Solution

1. Step 1: Understand the min heap role

   A min heap always keeps the smallest element at the root, making it easy to access the smallest values.

2. Step 2: Use min heap to find Kth smallest

   By extracting the root K times, we get the Kth smallest element.

3. Final Answer:

   Find the element that is the Kth smallest in a list using a min heap -> Option A

4. Quick Check:

   Kth smallest element = find using min heap [OK]

Hint: Extract min K times from min heap to get Kth smallest [OK]

Common Mistakes:

• Confusing min heap with max heap
• Thinking it sorts the entire list
• Assuming it finds the largest element

2. Which of the following is the correct way to insert an element into a min heap in JavaScript?

easy

A. heap.pop(element); heapifyDown(0);

B. heap.push(element); heapifyUp(heap.length - 1);

C. heap.unshift(element); heapifyDown(0);

D. heap.shift(element); heapifyUp(heap.length - 1);

Solution

1. Step 1: Insert element at the end

   Inserting into a heap means adding the element at the end of the array.

2. Step 2: Restore heap property by heapify up

   After insertion, heapify up is called from the inserted index to maintain min heap order.

3. Final Answer:

   heap.push(element); heapifyUp(heap.length - 1); -> Option B

4. Quick Check:

   Insert + heapifyUp = heap.push(element); heapifyUp(heap.length - 1); [OK]

Hint: Insert at end, then heapify up to fix min heap [OK]

Common Mistakes:

• Using pop or shift to insert elements
• Calling heapifyDown after insertion
• Inserting at the front of the array

3. What is the output of the following code snippet?

const heap = [1, 3, 6, 5, 9, 8];
function extractMin(heap) {
  const min = heap[0];
  heap[0] = heap.pop();
  heapifyDown(heap, 0);
  return min;
}
function heapifyDown(heap, i) {
  const left = 2 * i + 1;
  const right = 2 * i + 2;
  let smallest = i;
  if (left < heap.length && heap[left] < heap[smallest]) smallest = left;
  if (right < heap.length && heap[right] < heap[smallest]) smallest = right;
  if (smallest !== i) {
    [heap[i], heap[smallest]] = [heap[smallest], heap[i]];
    heapifyDown(heap, smallest);
  }
}
console.log(extractMin(heap));

medium

A. 6

B. 3

C. 5

D. 1

Solution

1. Step 1: Extract min element

   The min element is at heap[0], which is 1.

2. Step 2: Replace root and heapify down

   Replace root with last element 8, then heapify down to restore min heap.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   extractMin returns root = 1 [OK]

Hint: extractMin returns root element of min heap [OK]

Common Mistakes:

• Returning last element instead of root
• Not heapifying down after extraction
• Confusing min heap root with max

4. Identify the bug in this code snippet for finding the Kth smallest element using a min heap:

function kthSmallest(arr, k) {
  const heap = [];
  for (const num of arr) {
    heap.push(num);
  }
  for (let i = Math.floor(heap.length / 2); i >= 0; i--) {
    heapifyDown(heap, i);
  }
  let result;
  for (let i = 0; i < k; i++) {
    result = heap.shift();
    heapifyDown(heap, 0);
  }
  return result;
}

medium

A. Using shift() removes first element but does not maintain heap structure

B. Heap is not built correctly from array

C. Loop for heapifyDown should start from 0 to end

D. Variable result is not initialized

Solution

1. Step 1: Check element removal method

   Using shift() removes first element but shifts all others, breaking heap structure.

2. Step 2: Correct removal method

   Should remove root by swapping with last element, popping last, then heapify down.

3. Final Answer:

   Using shift() removes first element but does not maintain heap structure -> Option A

4. Quick Check:

   shift() breaks heap property [OK]

Hint: Remove root by swap and pop, not shift() [OK]

Common Mistakes:

• Using shift() instead of swap and pop
• Incorrect heap building loop range
• Ignoring heapify after removal

5. Given an array [7, 10, 4, 3, 20, 15] and k = 3, what is the Kth smallest element using a min heap approach?

hard

A. 4

B. 10

C. 7

D. 3

Solution

1. Step 1: Build min heap from array

   Min heap root is smallest element: 3.

2. Step 2: Extract min 3 times

   Extract 1st min: 3, 2nd min: 4, 3rd min: 7.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   3rd smallest element = 7 [OK]

Hint: Extract min K times; last extracted is Kth smallest [OK]

Common Mistakes:

• Counting index instead of extraction times
• Confusing Kth smallest with Kth largest
• Not building min heap properly