Bubble Sort Algorithm in DSA C++ - Build from Scratch

Bubble Sort Algorithm

📖 Scenario: You have a list of numbers that are not in order. You want to arrange them from smallest to largest, like sorting books by height on a shelf.

🎯 Goal: Build a program that uses the Bubble Sort Algorithm to sort a list of numbers in ascending order.

📋 What You'll Learn

Create an array called numbers with the exact values: 5, 3, 8, 4, 2

Create an integer variable called n that stores the size of the numbers array

Use nested for loops with variables i and j to implement the bubble sort logic

Swap adjacent elements if the left one is greater than the right one

Print the sorted array elements separated by spaces

💡 Why This Matters

🌍 Real World

Sorting is used in many places like organizing data, searching faster, and preparing lists for reports.

💼 Career

Understanding sorting algorithms like bubble sort helps in coding interviews and building efficient software.

1

Create the array of numbers

Create an integer array called numbers with these exact values: 5, 3, 8, 4, 2

DSA C++

// Create the array called numbers with values 5, 3, 8, 4, 2
// Your code here

Hint

Use the syntax int numbers[] = {value1, value2, ...}; to create the array.

2

Set the size of the array

Create an integer variable called n and set it to the size of the numbers array using sizeof(numbers) / sizeof(numbers[0])

DSA C++

int numbers[] = {5, 3, 8, 4, 2};
// Create the variable n to store the size of numbers
// Your code here

Hint

Use sizeof to find the total size of the array and divide by the size of one element.

3

Implement the bubble sort logic

Use nested for loops with variables i and j to compare and swap adjacent elements in numbers if the left element is greater than the right element

DSA C++

int numbers[] = {5, 3, 8, 4, 2};
int n = sizeof(numbers) / sizeof(numbers[0]);
// Use nested for loops with i and j to sort numbers using bubble sort
// Your code here

Hint

Use two loops: the outer loop with i and the inner loop with j. Swap elements if the left one is bigger.

4

Print the sorted array

Use a for loop with variable i to print each element of numbers separated by spaces

DSA C++

int numbers[] = {5, 3, 8, 4, 2};
int n = sizeof(numbers) / sizeof(numbers[0]);
for (int i = 0; i  numbers[j + 1]) {
            int temp = numbers[j];
            numbers[j] = numbers[j + 1];
            numbers[j + 1] = temp;
        }
    }
}
// Print the sorted array elements separated by spaces
// Your code here

Hint

Use std::cout inside a loop to print each number followed by a space.

Practice

1. What is the main idea behind the Bubble Sort algorithm?

easy

A. Divide the array into halves and sort each half separately

B. Repeatedly swap adjacent elements if they are in the wrong order

C. Select the smallest element and move it to the beginning

D. Insert each element into its correct position in a sorted part

Solution

1. Step 1: Understand Bubble Sort process

   Bubble Sort compares adjacent elements and swaps them if they are out of order.

2. Step 2: Identify the correct description

   This swapping of neighbors repeats until the whole list is sorted.

3. Final Answer:

   Repeatedly swap adjacent elements if they are in the wrong order -> Option B

4. Quick Check:

   Bubble Sort = Swap neighbors repeatedly [OK]

Hint: Bubble Sort swaps neighbors repeatedly until sorted [OK]

Common Mistakes:

• Confusing Bubble Sort with Selection Sort
• Thinking it divides the array like Merge Sort
• Assuming it inserts elements like Insertion Sort

2. Which of the following is the correct syntax for the inner loop of Bubble Sort in C++ to compare adjacent elements in an array arr of size n?

easy

A. for (int j = 0; j < n - i - 1; j++)

B. for (int j = 0; j < n; j++)

C. for (int j = 1; j < n - i; j++)

D. for (int j = 0; j <= n - i; j++)

Solution

1. Step 1: Understand inner loop range

   The inner loop runs from 0 to n - i - 1 because after each pass, the last i elements are sorted.

2. Step 2: Check each option

   for (int j = 0; j < n - i - 1; j++) correctly uses j < n - i - 1 to avoid out-of-bound and unnecessary comparisons.

3. Final Answer:

   for (int j = 0; j < n - i - 1; j++) -> Option A

4. Quick Check:

   Inner loop limit = n - i - 1 [OK]

Hint: Inner loop stops before sorted elements at end [OK]

Common Mistakes:

• Using j < n instead of j < n - i - 1
• Starting j from 1 instead of 0
• Using <= instead of < causing out-of-bound

3. What will be the output of the following C++ code snippet?

int arr[] = {5, 3, 8, 4};
int n = 4;
for (int i = 0; i < n - 1; i++) {
  for (int j = 0; j < n - i - 1; j++) {
    if (arr[j] > arr[j + 1]) {
      int temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}
for (int i = 0; i < n; i++) {
  std::cout << arr[i] << " ";
}

medium

A. 3 5 4 8

B. 5 3 4 8

C. 8 5 4 3

D. 3 4 5 8

Solution

1. Step 1: Trace first pass of Bubble Sort

   Compare pairs: (5,3) swap -> {3,5,8,4}, (5,8) no swap, (8,4) swap -> {3,5,4,8}

2. Step 2: Trace second pass and final array

   Next pass: (3,5) no swap, (5,4) swap -> {3,4,5,8}, last pass no swaps needed.

3. Final Answer:

   3 4 5 8 -> Option D

4. Quick Check:

   Sorted array = 3 4 5 8 [OK]

Hint: Bubble Sort pushes largest to end each pass [OK]

Common Mistakes:

• Not swapping correctly on first pass
• Confusing order of swaps
• Printing unsorted array

4. Identify the error in the following Bubble Sort code snippet and select the correct fix:

void bubbleSort(int arr[], int n) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n - i; j++) {
      if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}

medium

A. Add a swap flag to optimize and stop early if sorted

B. Change outer loop to i < n - 1 to reduce unnecessary passes

C. Change inner loop to j < n - i - 1 to avoid out-of-bound access

D. No error, code is correct

Solution

1. Step 1: Analyze inner loop condition

   Inner loop uses j < n - i, but accesses arr[j + 1], which causes out-of-bound when j = n - i - 1.

2. Step 2: Correct inner loop limit

   Changing to j < n - i - 1 prevents accessing arr[n], fixing runtime error.

3. Final Answer:

   Change inner loop to j < n - i - 1 to avoid out-of-bound access -> Option C

4. Quick Check:

   Inner loop limit fixes out-of-bound [OK]

Hint: Inner loop must stop before last compared index [OK]

Common Mistakes:

• Ignoring out-of-bound access
• Changing outer loop only
• Assuming code is correct without checking array access

5. Given an array arr = {7, 2, 9, 4, 3}, how many total swaps will Bubble Sort perform to sort it in ascending order?

hard

A. 6

B. 5

C. 4

D. 7

Solution

1. Step 1: Trace swaps in each pass

   Pass 1: (7,2) swap, (7,9) no, (9,4) swap, (9,3) swap -> 3 swaps
   Array now: {2,7,4,3,9}

2. Step 2: Continue tracing swaps

   Pass 2: (2,7) no, (7,4) swap, (7,3) swap -> 2 swaps
   Array now: {2,4,3,7,9}
   Pass 3: (2,4) no, (4,3) swap -> 1 swap
   Array now: {2,3,4,7,9}
   Pass 4: no swaps

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Total swaps counted = 6 [OK]

Hint: Count swaps each pass until no swaps left [OK]

Common Mistakes:

• Counting comparisons instead of swaps
• Stopping early without counting all passes
• Miscounting swaps in passes