Heap Sort Algorithm in DSA C++ - 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 repeatedly extract the largest element and place it at the end of the array, sorting the array in ascending order.

beginner

What is a max-heap?

A max-heap is a complete binary tree where each parent node is greater than or equal to its child nodes. This property helps quickly find the largest element at the root.

intermediate

What are the two main steps in Heap Sort?

1. Build a max-heap from the input array.
2. Repeatedly swap the root (largest) with the last element, reduce heap size, and heapify the root to maintain max-heap.

intermediate

What is the time complexity of Heap Sort and why?

Heap Sort runs in O(n log n) time because building the heap takes O(n), and each of the n elements is extracted with a heapify operation costing O(log n).

beginner

Why is Heap Sort considered an in-place sorting algorithm?

Heap Sort sorts the array without needing extra space for another array. It rearranges elements within the original array, using only a small amount of extra memory for variables.

What data structure does Heap Sort use to organize elements?

A Linked List

B Queue

C Heap

D Stack

Heap Sort uses a heap, specifically a max-heap, to organize elements for sorting.

In Heap Sort, what is the root of the max-heap?

A Smallest element

B Random element

C Middle element

D Largest element

The root of a max-heap is always the largest element.

What is the time complexity of Heap Sort in the average case?

A O(n log n)

B O(n^2)

C O(log n)

D O(n)

Heap Sort runs in O(n log n) time on average.

Which step is NOT part of Heap Sort?

A Sorting by insertion

B Swapping root with last element

C Building a max-heap

D Heapifying the root

Heap Sort does not use insertion sort; it uses heap operations.

Heap Sort is considered an in-place algorithm because:

A It uses extra arrays

B It sorts without extra space

C It uses recursion

D It uses linked lists

Heap Sort sorts the array within the original space without needing extra arrays.

Explain the process of building a max-heap from an unsorted array.

Think about fixing the heap from bottom to top.

Describe how Heap Sort extracts elements to produce a sorted array.

Focus on how the largest element moves to the end each time.

Practice

1. What is the main purpose of the heapify operation in the Heap Sort Algorithm?

easy

A. To reverse the array elements

B. To sort the array directly without building a heap

C. To swap the first and last elements of the array

D. To build a max heap or min heap from an unordered array

Solution

1. Step 1: Understand heapify's role

   Heapify rearranges elements to satisfy the heap property, making the array a max heap or min heap.

2. Step 2: Connect heapify to heap sort

   Heap sort uses heapify to build the heap before sorting by repeatedly extracting the root.

3. Final Answer:

   To build a max heap or min heap from an unordered array -> Option D

4. Quick Check:

   Heapify builds heap = A [OK]

Hint: Heapify creates heap structure before sorting [OK]

Common Mistakes:

• Thinking heapify sorts the array directly
• Confusing heapify with swapping elements
• Assuming heapify reverses the array

2. Which of the following is the correct syntax to swap two elements arr[i] and arr[j] in C++ during heap sort?

easy

A. arr.swap(i, j);

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

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

D. swap arr[i], arr[j];

Solution

1. Step 1: Recall C++ swap syntax

   The standard way to swap two elements is using the swap() function with parentheses and commas.

2. Step 2: Check each option

   swap(arr[i], arr[j]); uses correct syntax. arr[i] = arr[j]; arr[j] = arr[i]; overwrites values incorrectly. swap arr[i], arr[j]; misses parentheses. arr.swap(i, j); is invalid method call.

3. Final Answer:

   swap(arr[i], arr[j]); -> Option C

4. Quick Check:

   Correct swap syntax = D [OK]

Hint: Use swap() with parentheses and commas in C++ [OK]

Common Mistakes:

• Assigning values instead of swapping
• Missing parentheses in swap function
• Using non-existent swap methods

3. What will be the output array after applying heap sort on arr = [4, 10, 3, 5, 1]? Print the sorted array.

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: Build max heap from array

   Max heap of [4,10,3,5,1] rearranges to [10,5,3,4,1].

2. Step 2: Extract max and heapify repeatedly

   Extract 10, heapify remaining; then 5, then 4, then 3, then 1 results in sorted ascending array [1,3,4,5,10].

3. Final Answer:

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

4. Quick Check:

   Heap sort ascending = [1,3,4,5,10] [OK]

Hint: Heap sort outputs ascending sorted array [OK]

Common Mistakes:

• Confusing max heap with sorted array
• Reading heap array as sorted directly
• Outputting descending order instead

4. Identify the error in this heap sort snippet and choose the correct fix:

void heapify(int arr[], int n, int i) {
  int largest = i;
  int left = 2*i;
  int right = 2*i + 1;
  if (left < n && arr[left] > arr[largest]) largest = left;
  if (right < n && arr[right] > arr[largest]) largest = right;
  if (largest != i) {
    swap(arr[i], arr[largest]);
    heapify(arr, n, largest);
  }
}

medium

A. Remove recursive call to heapify

B. Change left and right to 2*i + 1 and 2*i + 2 respectively

C. Change largest initialization to 0

D. Change swap to arr[i] = arr[largest]

Solution

1. Step 1: Check child index calculation

   In 0-based arrays, left child = 2*i + 1, right child = 2*i + 2. Current code uses 2*i and 2*i + 1 which is incorrect.

2. Step 2: Fix child indices

   Changing left and right to 2*i + 1 and 2*i + 2 fixes indexing and prevents out-of-bound errors.

3. Final Answer:

   Change left and right to 2*i + 1 and 2*i + 2 respectively -> Option B

4. Quick Check:

   Child indices = 2*i+1, 2*i+2 [OK]

Hint: Use 0-based indexing: left=2*i+1, right=2*i+2 [OK]

Common Mistakes:

• Using 1-based indexing formulas in 0-based arrays
• Removing recursion breaks heapify
• Incorrect swap assignment instead of swap function

5. Given an array arr = [12, 11, 13, 5, 6, 7], how many times will the heapify function be called during the build heap phase of heap sort?

hard

A. 4 times

B. 3 times

C. 2 times

D. 5 times

Solution

1. Step 1: Understand build heap calls

   Build heap calls heapify from last non-leaf node down to root. For array size 6, last non-leaf node is at index 2 (0-based).

2. Step 2: Count heapify calls

   Heapify called at indices 2, 1, 0 during build heap phase, totaling 3 calls. However, heapify may call itself recursively inside these calls. Counting only initial calls, it's 3.

3. Step 3: Clarify question intent

   If question means initial calls only, answer is 3. If counting recursive calls inside heapify, index 1 and 0 calls may cause extra heapify calls. For this array, heapify at index 1 calls heapify at index 4 (leaf, no call), index 0 calls heapify at index 1 again, so total calls are 4.

4. Final Answer:

   4 times -> Option A

5. Quick Check:

   Build heap calls heapify 3 + 1 recursive = 4 [OK]

Hint: Count initial + recursive heapify calls during build heap [OK]

Common Mistakes:

• Counting only initial calls, ignoring recursion
• Confusing build heap with sorting phase calls
• Misidentifying last non-leaf node index