Write a Program to Sort an Array Using Bubble Sort in C

Write a Program to Sort an Array Using Bubble Sort

Sorting is a fundamental operation in programming that allows us to arrange data in a specific order. One of the simplest sorting algorithms is bubble sort. In this blog post, we will walk you through writing a C program to sort an array using bubble sort, explaining how it works and breaking down the code in detail.

1. Understanding Bubble Sort

Bubble sort is a straightforward comparison-based algorithm. It works by repeatedly stepping through the list, comparing adjacent elements and swapping them if they are in the wrong order. The process is repeated until no swaps are needed, indicating that the list is sorted.

2. How Bubble Sort Works

Here’s a step-by-step explanation of how bubble sort operates:

1. Start at the beginning of the array.
2. Compare the first two elements. If the first is greater than the second, swap them.
3. Move to the next pair of elements and repeat the comparison and possible swap.
4. Continue this process for the entire array.
5. After each pass, the largest unsorted element is "bubbled" to its correct position.
6. Repeat the process for the entire array until no swaps are needed.

3. Writing the Program

Let’s implement the bubble sort algorithm in C.

Code Example: Sorting an Array Using Bubble Sort

#include <stdio.h>

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

int main() {
    int n;

    // Prompt user to enter the number of elements
    printf("Enter the number of elements in the array: ");
    scanf("%d", &n);

    int arr[n];

    // Prompt user to enter the elements of the array
    printf("Enter %d elements:\n", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // Sort the array using bubble sort
    bubbleSort(arr, n);

    // Output the sorted array
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

Explanation of the Code

In this program:

• We include the stdio.h header file for input/output functions.
• We define a function bubbleSort that takes an array and its size as parameters.
• Inside the bubbleSort function, we use two nested loops. The outer loop iterates through the entire array, while the inner loop compares and swaps adjacent elements.
• If the current element is greater than the next, we swap them using a temporary variable.
• In the main function, we prompt the user to enter the number of elements and read the array values.
• After sorting the array using the bubbleSort function, we print the sorted array.

4. Example Output

Here’s an example of how the program works:

Enter the number of elements in the array: 5
Enter 5 elements:
64
34
25
12
22
Sorted array: 12 22 25 34 64 

5. Common Mistakes to Avoid

When implementing this program, keep an eye out for the following common mistakes:

• Incorrect Loop Boundaries: Ensure that the inner loop correctly iterates up to n - i - 1 to avoid accessing out of bounds.
• Forgetting to Initialize Variables: Ensure all variables are initialized properly to avoid unexpected behavior.
• Not Using Temporary Variables for Swapping: Ensure you use a temporary variable to swap values correctly without losing data.

6. Expanding the Program

Now that you have a basic program to sort an array using bubble sort, consider these ideas for expanding it:

• Modify the program to implement other sorting algorithms, such as selection sort or insertion sort.
• Enhance the program to sort arrays in descending order.
• Write a function that sorts multiple arrays and compares their performance.

7. Conclusion

In this post, we learned how to write a C program to sort an array using the bubble sort algorithm. We provided a clear code example, detailed explanations, and discussed common pitfalls to avoid.

Sorting is a fundamental concept in programming, and mastering algorithms like bubble sort will strengthen your understanding of data structures and algorithmic thinking. Keep practicing, and you’ll continue to improve your programming skills!