Heap Sort Algorithm in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Heap Sort algorithm?

Heap Sort uses a special tree structure called a heap to sort elements. It builds a max heap to find the largest element quickly, then swaps it to the end and rebuilds the heap until sorted.

beginner

What is a max heap?

A max heap is a binary tree where each parent node is greater than or equal to its children. This means the largest value is always at the root.

intermediate

Why do we rebuild the heap after swapping the root with the last element in Heap Sort?

After swapping, the heap property might break. Rebuilding (heapifying) fixes the heap so the largest element moves to the root again for the next swap.

intermediate

What is the time complexity of Heap Sort?

Heap Sort runs in O(n log n) time because building the heap takes O(n) and each of the n removals takes O(log n) to restore the heap.

advanced

How does Heap Sort differ from other sorting algorithms like Quick Sort or Merge Sort?

Heap Sort uses a heap data structure and sorts in place without extra memory. Quick Sort is faster on average but not stable. Merge Sort is stable but uses extra space.

What data structure does Heap Sort use to organize elements?

A Linked List

B Stack

C Queue

D Heap

Heap Sort uses a heap, a special binary tree structure, to organize elements for sorting.

In a max heap, where is the largest element located?

A At the root

B At the left child

C At the right child

D At the leaf nodes

The largest element in a max heap is always at the root node.

What is the main step after swapping the root with the last element in Heap Sort?

A Reverse the array

B Heapify the root to restore heap property

C Swap the first two elements

D Sort the entire array again

After swapping, heapify is done to restore the heap property starting from the root.

What is the average time complexity of Heap Sort?

A O(log n)

B O(n^2)

C O(n log n)

D O(n)

Heap Sort runs in O(n log n) time on average and in the worst case.

Which of these is true about Heap Sort?

A It sorts in place without extra memory

B It always uses extra memory

C It is unstable and uses extra memory

D It is faster than Quick Sort in all cases

Heap Sort sorts in place and does not require extra memory, unlike Merge Sort.

Explain how Heap Sort uses a max heap to sort an array step-by-step.

Think about how the largest element moves to the end each time.

Describe the difference between a max heap and a min heap and why Heap Sort uses a max heap.

Focus on the root element's value in each heap type.

Practice

1. What is the main purpose of the heap in the Heap Sort algorithm?

easy

A. To reverse the array elements

B. To store elements in sorted order permanently

C. To count the number of elements in the array

D. To efficiently find and remove the largest (or smallest) element

Solution

1. Step 1: Understand heap property

   A heap is a special tree-based structure that allows quick access to the largest (max-heap) or smallest (min-heap) element.

2. Step 2: Role in Heap Sort

   Heap Sort uses the heap to repeatedly extract the largest element and place it at the end, sorting the array.

3. Final Answer:

   To efficiently find and remove the largest (or smallest) element -> Option D

4. Quick Check:

   Heap = fast max/min access [OK]

Hint: Heap helps quickly get max or min element [OK]

Common Mistakes:

• Thinking heap stores sorted elements permanently
• Confusing heap with simple array storage
• Assuming heap reverses the array

2. Which of the following is the correct way to swap two elements arr[i] and arr[j] in JavaScript during Heap Sort?

easy

A. let temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;

B. arr[i], arr[j] = arr[j], arr[i];

C. swap(arr[i], arr[j]);

D. arr[i] = arr[j]; arr[j] = arr[i];

Solution

1. Step 1: Understand JavaScript swap syntax

   JavaScript does not support tuple unpacking like Python, so swapping requires a temporary variable.

2. Step 2: Check each option

   let temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; uses a temporary variable correctly. arr[i], arr[j] = arr[j], arr[i]; is Python syntax, swap(arr[i], arr[j]); is undefined function, arr[i] = arr[j]; arr[j] = arr[i]; overwrites values incorrectly.

3. Final Answer:

   let temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; -> Option A

4. Quick Check:

   Use temp variable to swap [OK]

Hint: Use temp variable to swap in JS [OK]

Common Mistakes:

• Using Python-style tuple swap in JS
• Calling undefined swap function
• Overwriting values without temp variable

3. What will be the output array after applying Heap Sort on [4, 10, 3, 5, 1]?

medium

A. [1, 3, 4, 5, 10]

B. [10, 5, 4, 3, 1]

C. [1, 4, 3, 5, 10]

D. [5, 10, 4, 3, 1]

Solution

1. Step 1: Understand Heap Sort output

   Heap Sort sorts the array in ascending order by default.

2. Step 2: Sort the array

   Sorting [4, 10, 3, 5, 1] gives [1, 3, 4, 5, 10].

3. Final Answer:

   [1, 3, 4, 5, 10] -> Option A

4. Quick Check:

   Sorted ascending = [1, 3, 4, 5, 10] [OK]

Hint: Heap Sort outputs sorted ascending array [OK]

Common Mistakes:

• Confusing heap structure with final sorted array
• Thinking output is descending by default
• Mixing up original and sorted arrays

4. Identify the error in this Heap Sort snippet:

function heapSort(arr) {
  let n = arr.length;
  for (let i = Math.floor(n / 2); i >= 0; i--) {
    heapify(arr, n, i);
  }
  for (let i = n - 1; i > 0; i--) {
    let temp = arr[0];
    arr[0] = arr[i];
    arr[i] = temp;
    heapify(arr, i, 0);
  }
}

medium

A. Swapping elements is done incorrectly

B. The first for loop should start from Math.floor(n / 2) - 1

C. The second for loop should start from i = 0

D. heapify function is called with wrong parameters

Solution

1. Step 1: Check heap building loop

   The first loop builds the heap and should start from the last non-leaf node at index Math.floor(n / 2) - 1, not Math.floor(n / 2).

2. Step 2: Verify other parts

   The second loop and swapping are correct. heapify parameters are also correct.

3. Final Answer:

   The first for loop should start from Math.floor(n / 2) - 1 -> Option B

4. Quick Check:

   Heap build starts at last non-leaf node [OK]

Hint: Heap build starts at floor(n/2)-1 [OK]

Common Mistakes:

• Starting heap build loop at wrong index
• Incorrect swap logic
• Wrong heapify parameters

5. Given an array [12, 11, 13, 5, 6, 7], how many times will the heapify function be called during the entire Heap Sort process?

hard

A. 6 times

B. 10 times

C. 13 times

D. 15 times

Solution

1. Step 1: Count heapify calls during heap build

   Heap build calls heapify top-level from index floor(n/2)-1=2 down to 0 (3 top-level). For this array, heapify(6,0) recurses once to heapify(6,2), total 4 calls.

2. Step 2: Count heapify calls during sorting

   After building heap, heapify called top-level 5 times (i=5 to 1). Tracing: i=5:2 calls, i=4:2, i=3:2, i=2:2, i=1:1, total 9 calls.

3. Step 3: Total calls

   Total heapify calls = 4 (build) + 9 (sort) = 13.

4. Final Answer:

   13 times -> Option C

5. Quick Check:

   Heapify calls = build + sort + recursive calls = 13 [OK]

Hint: Count build + sort + recursive heapify calls =13 [OK]

Common Mistakes:

• Counting only build or only sort calls
• Ignoring recursive heapify calls
• Assuming heapify called once per element