Heap Insert Operation Bubble Up in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the heap array after inserting 15?

Given a max-heap represented as an array, what is the array after inserting the value 15 and performing bubble up?

DSA Typescript

const heap = [20, 18, 10, 12, 9];
function insert(heap: number[], value: number): number[] {
  heap.push(value);
  let index = heap.length - 1;
  while (index > 0) {
    let parentIndex = Math.floor((index - 1) / 2);
    if (heap[parentIndex] >= heap[index]) break;
    [heap[parentIndex], heap[index]] = [heap[index], heap[parentIndex]];
    index = parentIndex;
  }
  return heap;
}
const result = insert(heap, 15);
console.log(result);

A [20, 18, 15, 12, 9, 10]

B [20, 18, 10, 15, 9, 12]

C [20, 18, 15, 12, 9, 10, 15]

D [20, 18, 10, 12, 9, 15]

💡 Hint

Remember to bubble up the inserted value until the max-heap property is restored.

The inserted value 15 is added at the end. It swaps with 10 because 15 > 10, resulting in [20, 18, 15, 12, 9, 10]. No further swaps needed.

❓ Predict Output

intermediate

What is the heap array after inserting 5?

Given a max-heap array, what is the array after inserting 5 and performing bubble up?

DSA Typescript

const heap = [30, 20, 15, 10, 8];
function insert(heap: number[], value: number[]): number[] {
  heap.push(value);
  let index = heap.length - 1;
  while (index > 0) {
    let parentIndex = Math.floor((index - 1) / 2);
    if (heap[parentIndex] >= heap[index]) break;
    [heap[parentIndex], heap[index]] = [heap[index], heap[parentIndex]];
    index = parentIndex;
  }
  return heap;
}
const result = insert(heap, 5);
console.log(result);

A [30, 20, 15, 10, 8, 5]

B [30, 20, 5, 10, 8, 15]

C [30, 20, 15, 5, 8, 10]

D [30, 20, 15, 10, 5, 8]

💡 Hint

If the inserted value is smaller than its parent, no swaps occur.

5 is added at the end and is smaller than its parent 15, so no bubble up happens. The heap remains [30, 20, 15, 10, 8, 5].

🔧 Debug

advanced

Why does this bubble up code cause an infinite loop?

Identify the bug causing an infinite loop in this bubble up implementation for a max-heap insert.

DSA Typescript

function bubbleUp(heap: number[], index: number): void {
  while (index > 0) {
    let parentIndex = Math.floor(index / 2);
    if (heap[parentIndex] >= heap[index]) break;
    [heap[parentIndex], heap[index]] = [heap[index], heap[parentIndex]];
    index = parentIndex;
  }
}
const heap = [50, 30, 40, 10, 20];
bubbleUp(heap, 4);
console.log(heap);

A The function should return the heap array after bubble up

B The swap syntax is incorrect; should use a temp variable

C The loop condition should be index >= 0 instead of index > 0

D parentIndex calculation is wrong; should be Math.floor((index - 1) / 2)

💡 Hint

Check how parent index is calculated for zero-based arrays.

Using Math.floor(index / 2) causes wrong parent index calculation, leading to infinite loop because index may not decrease properly. Correct formula is Math.floor((index - 1) / 2).

❓ Predict Output

advanced

What is the heap array after inserting 25?

Given a max-heap array, what is the array after inserting 25 and performing bubble up?

DSA Typescript

const heap = [40, 30, 20, 10, 15, 5];
function insert(heap: number[], value: number): number[] {
  heap.push(value);
  let index = heap.length - 1;
  while (index > 0) {
    let parentIndex = Math.floor((index - 1) / 2);
    if (heap[parentIndex] >= heap[index]) break;
    [heap[parentIndex], heap[index]] = [heap[index], heap[parentIndex]];
    index = parentIndex;
  }
  return heap;
}
const result = insert(heap, 25);
console.log(result);

A [40, 30, 25, 10, 15, 5, 20, 25]

B [40, 30, 20, 10, 15, 5, 25]

C [40, 30, 25, 10, 15, 5, 20]

D [40, 30, 20, 10, 15, 25, 5]

💡 Hint

Bubble up swaps inserted value with parents until heap property is restored.

25 is inserted at the end, swaps with 20 because 25 > 20, resulting in [40, 30, 25, 10, 15, 5, 20]. No further swaps needed.

🧠 Conceptual

expert

How many swaps occur when inserting 100 into this max-heap?

Given the max-heap array [90, 70, 80, 40, 50, 60, 30], how many swaps happen when inserting 100 and performing bubble up?

DSA Typescript

const heap = [90, 70, 80, 40, 50, 60, 30];
function insert(heap: number[], value: number): number[] {
  heap.push(value);
  let index = heap.length - 1;
  let swaps = 0;
  while (index > 0) {
    let parentIndex = Math.floor((index - 1) / 2);
    if (heap[parentIndex] >= heap[index]) break;
    [heap[parentIndex], heap[index]] = [heap[index], heap[parentIndex]];
    index = parentIndex;
    swaps++;
  }
  return heap;
}
const result = insert(heap, 100);
console.log(result);

A 2

B 3

C 4

D 1

💡 Hint

Count how many times the inserted value swaps with its parent until it reaches the root or no longer bigger.

100 swaps with 30 (1), then 80 (2), then 90 (3) and stops at root. Total swaps = 3.