Data Structure 

DATA STRUCTURES AND ALGORITHM – Best Sorting Algorithms – Bubble sort Algorithm Bubble sort in C

Lui Kreyszig 0 Comments

DATA STRUCTURES AND ALGORITHM – Best Sorting Algorithms – Bubble sort Algorithm Bubble sort in C

play-rounded-fill play-rounded-outline play-sharp-fill play-sharp-outline
pause-sharp-outline pause-sharp-fill pause-rounded-outline pause-rounded-fill
00:00
© 2018 Flowplayer ABAbout FlowplayerGPL based license

Bubble Sort Algorithm in C – Explanation & Code

Bubble Sort is one of the simplest sorting algorithms. It repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This process is repeated until the list is sorted.



 How Bubble Sort Works?

  1. Compare adjacent elements.
  2. Swap them if they are in the wrong order.
  3. Move to the next pair and repeat.
  4. Continue this process for every element.
  5. Repeat the entire process for multiple passes until the array is sorted.

Best Case (Already Sorted): O(n)
Worst Case (Reverse Sorted): O(n²)
Average Case: O(n²)
Stable Sort: Yes
In-Place Algorithm: Yes

 Bubble Sort Algorithm in C

#include <stdio.h>

// Function to perform Bubble Sort
void bubbleSort(int arr[], int n) {
int i, j, temp;
int swapped;

for (i = 0; i < n – 1; i++) {
swapped = 0; // Flag to check if swapping happened

for (j = 0; j < n – i – 1; j++) {
if (arr[j] > arr[j + 1]) { // Swap if the current element is greater than the next
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}

// If no two elements were swapped, break the loop (Optimization)
if (swapped == 0)
break;
}
}

// Function to print an array
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++)
printf(“%d “, arr[i]);
printf(“\n”);
}

// Main function
int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);

printf(“Original array: “);
printArray(arr, n);

bubbleSort(arr, n);

printf(“Sorted array: “);
printArray(arr, n);

return 0;
}

Explanation of Code

  1. Outer Loop: Runs for (n-1) passes to move the largest element to the end.
  2. Inner Loop: Compares adjacent elements and swaps them if they are out of order.
  3. Optimization: If no swaps occur in a pass, the array is already sorted, and the loop breaks.
  4. Function Usage:
    • bubbleSort() performs sorting.
    • printArray() prints the array before and after sorting.

 Example Execution

Input:

int arr[] = {64, 25, 12, 22, 11};

Sorting Process:

Pass 1: [25, 12, 22, 11, 64]
Pass 2: [12, 22, 11, 25, 64]
Pass 3: [12, 11, 22, 25, 64]
Pass 4: [11, 12, 22, 25, 64]

Output:

Original array: 64 25 12 22 11
Sorted array: 11 12 22 25 64

 Advantages & Disadvantages

Advantages:

  • Simple and easy to implement.
  • Works well for small datasets.
  • Stable sorting algorithm.

Disadvantages:

  • Inefficient for large datasets.
  • Time complexity O(n²) makes it slow compared to other sorting algorithms.

 Alternative Sorting Algorithms

  • Selection Sort – More efficient but still O(n²).
  • Insertion Sort – Efficient for nearly sorted arrays.
  • Merge Sort & Quick Sort – More efficient, O(n log n).

Would you like an optimized sorting algorithm like Quick Sort or Merge Sort in C?

DATA STRUCTURES AND ALGORITHM – Best Sorting Algorithms – Bubble sort Algorithm Bubble sort in C

V: Sorting: Bubble sort, Merge sort, Insertion Sort, Selection …

Data Structures & Algorithms Bubble Sort

Here’s a complete guide to Bubble Sort Algorithm—a classic sorting technique, especially useful for understanding the basics of data structures and algorithms.

📚 Best Sorting Algorithms (Quick Overview)

Here are some commonly used sorting algorithms:

Algorithm Time Complexity Use Case
Bubble Sort O(n²) Easy to understand, educational
Selection Sort O(n²) Simple, not efficient for large data
Insertion Sort O(n²) Good for nearly sorted data
Merge Sort O(n log n) Fast, stable, divide-and-conquer
Quick Sort O(n log n) Very fast, widely used
Heap Sort O(n log n) Good for memory-constrained systems

🔁 What is Bubble Sort?

Bubble Sort is a simple algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.

🔸 How It Works:

  • Compare each pair of adjacent elements.

  • Swap them if they are in the wrong order.

  • Repeat the process for all elements until the array is sorted.

🧠 Key Idea:

Larger values “bubble up” to the end of the array with each pass.

✅ Bubble Sort Algorithm (Steps)

  1. Start at the beginning of the array.

  2. Compare the current element with the next one.

  3. Swap them if the current is greater than the next.

  4. Move to the next element and repeat until the end.

  5. Repeat the entire process n-1 times or until no swaps are needed.

💻 Bubble Sort in C

c

#include <stdio.h>

void bubbleSort(int arr[], int n) {
int i, j, temp;
int swapped;

for (i = 0; i < n – 1; i++) {
swapped = 0; // Flag to check if any swap occurred

for (j = 0; j < n – i – 1; j++) {
// Compare adjacent elements
if (arr[j] > arr[j + 1]) {
// Swap them
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}

// If no swap occurred, the array is already sorted
if (!swapped)
break;
}
}

void printArray(int arr[], int size) {
for (int i = 0; i < size; i++)
printf(“%d “, arr[i]);
printf(“\n”);
}

int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr)/sizeof(arr[0]);

printf(“Original array:\n”);
printArray(arr, n);

bubbleSort(arr, n);

printf(“Sorted array:\n”);
printArray(arr, n);
return 0;
}

📌 Output:

php
Original array:
64 34 25 12 22 11 90
Sorted array:
11 12 22 25 34 64 90

🧪 Time and Space Complexity

Case Time Complexity
Best (Sorted) O(n)
Average O(n²)
Worst O(n²)
Space O(1)

✅ When to Use Bubble Sort

  • For small datasets

  • For learning purposes

  • When simplicity is more important than speed

Would you like examples of other sorting algorithms in C, or a comparison chart for when to use each one?

DATA STRUCTURES AND ALGORITHM – Best Sorting Algorithms – Bubble sort Algorithm Bubble sort in C

Searching and Sorting



You May Also Like

Knapsack problem of Greedy method [ understand with real life example].

Lui Kreyszig 0

Greedy Algorithm in data structure [ with basic concept]

Lui Kreyszig 0

Leave a Reply

Your email address will not be published. Required fields are marked *

error: