ALGORITHM READING NOTE

Bubble Sort

Bubble sort repeatedly compares adjacent values and swaps out-of-order pairs, causing large values to 'bubble' toward the end.

TYPEAlgorithmCATEGORYSortingDEPTHBeginnerTYPICAL COMPLEXITYO(n²)

SHORT INTERVIEW ANSWER

Start with this mental model

Bubble sort repeatedly compares adjacent values and swaps out-of-order pairs, causing large values to 'bubble' toward the end.

SIMPLE EXPLANATION

How it works, without unnecessary jargon

After one full pass, the largest unsorted value is in its final position.

With an early-exit flag, an already sorted array can finish in O(n).

EXECUTION

Read the algorithm as a sequence of decisions

Understand what one pass/partition/merge guarantees.

Track which region is already finalized.

Reason about comparisons, swaps/moves and extra memory.

A small example to keep in mind

Read a tiny input by hand and write down the state after every important operation. For Bubble Sort, the goal is to make the invariant visible rather than to memorize code.

READABLE JAVASCRIPT IMPLEMENTATIONJavaScript

function bubbleSort(input) {
  const a = [...input];
  for (let end = a.length - 1; end > 0; end--) {
    let swapped = false;
    for (let i = 0; i < end; i++) {
      if (a[i] > a[i + 1]) {
        [a[i], a[i + 1]] = [a[i + 1], a[i]];
        swapped = true;
      }
    }
    if (!swapped) break;
  }
  return a;
}

How to read this code

Do not memorize the syntax. Follow the state that changes on each line and connect it to the invariant described above.

COMPLEXITY

O(n²)

Do not quote this complexity mechanically. Ask which operation or input dimension it describes, then derive the cost from the loops, recursion depth, data-structure operations and any preprocessing assumptions.

WHEN TO USE IT

Good fit

Choose based on input size, order, key range, stability and memory limits.

COMMON MISTAKES

What usually goes wrong

Forgetting the shrinking end boundary.
Using it for large real workloads where O(n²) is too expensive.

HOW TO EXPLAIN IT IN AN INTERVIEW

A professional answer shape

Use it mainly to demonstrate sorting fundamentals, stability and best/average/worst-case reasoning rather than as a production default.

Problem→Core idea→Invariant / state→Big-O→Trade-off

QUICK INTERVIEW CHECK

What problem does Bubble Sort solve?

Bubble sort repeatedly compares adjacent values and swaps out-of-order pairs, causing large values to 'bubble' toward the end.

What should I mention about complexity?

Its typical cost here is O(n²), but a complete answer should connect that cost to the representation, input constraints and the dominant operations.

What is the most common mistake?

Forgetting the shrinking end boundary.

Continue readingStable sortingIn-place sortingDivide and conquer

function bubbleSort(input) { const a = [...input]; for (let end = a.length - 1; end > 0; end--) { let swapped = false; for (let i = 0; i < end; i++) { if (a[i] > a[i + 1]) { [a[i], a[i + 1]] = [a[i + 1], a[i]]; swapped = true; } } if (!swapped) break; } return a; }