Python Tutorial

Bubble Sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. It is named "Bubble Sort" because smaller elements "bubble" to the top of the list. While not the most efficient sorting algorithm, it is easy to understand and implement, making it a good starting point for learning about sorting algorithms. In this article, we will delve into the concept of Bubble Sort, provide a Python implementation with output, and discuss the time complexity of the algorithm.

Understanding Bubble Sort

The basic idea behind Bubble Sort is to iterate through the list multiple times, comparing adjacent elements and swapping them if they are out of order. The process continues until no more swaps are needed, indicating that the list is now sorted. The algorithm gets its name from the way smaller elements gradually move to the top of the list, much like bubbles rising to the surface.

Let's break down the steps of the Bubble Sort algorithm:

Iterate through the list: Start from the beginning of the list and compare each pair of adjacent elements.
Compare and swap: If the elements are in the wrong order, swap them. This ensures that the larger element "bubbles up" and the smaller one moves down.
Continue iterating: Repeat the process for each pair of adjacent elements until the end of the list is reached.
Repeat until sorted: Keep iterating through the list until no more swaps are needed. At this point, the list is sorted.

While Bubble Sort is straightforward to understand, it is not the most efficient sorting algorithm, especially for large datasets. Its time complexity is O(n^2) in the worst case, where "n" is the number of elements in the list. This quadratic time complexity makes it less suitable for large datasets when compared to more advanced sorting algorithms.

Python Implementation of Bubble Sort

Now, let's implement Bubble Sort in Python and observe its behavior with a sample list:

def bubble_sort(arr):
    n = len(arr)

    # Traverse through all array elements
    for i in range(n):
        # Last i elements are already sorted, so we don't need to check them
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

# Example usage
if __name__ == "__main__":
    # Sample list to be sorted
    sample_list = [64, 34, 25, 12, 22, 11, 90]

    # Display the original list
    print("Original List:", sample_list)

    # Apply Bubble Sort
    bubble_sort(sample_list)

    # Display the sorted list
    print("Sorted List:", sample_list)

In this implementation, the bubble_sort function takes a list (arr) as its parameter and sorts it in-place. The nested loop compares adjacent elements and swaps them if they are in the wrong order. The outer loop ensures that the process is repeated until the entire list is sorted.

Output and Explanation

Let's run the provided Python code with the sample list and observe the output:

Original List: [64, 34, 25, 12, 22, 11, 90]
Sorted List: [11, 12, 22, 25, 34, 64, 90]

Here, the original list [64, 34, 25, 12, 22, 11, 90] is successfully sorted using the Bubble Sort algorithm, resulting in the sorted list [11, 12, 22, 25, 34, 64, 90].

The algorithm iterates through the list multiple times, comparing and swapping elements until the entire list is sorted. In each pass, the largest unsorted element "bubbles up" to its correct position. This process continues until no more swaps are needed, indicating that the list is fully sorted.

While Bubble Sort successfully sorts the list, it's important to note that its time complexity makes it less efficient for large datasets compared to other sorting algorithms like Merge Sort or Quick Sort.

Time Complexity of Bubble Sort

Understanding the time complexity of an algorithm is crucial for evaluating its efficiency, especially when dealing with large datasets. The time complexity of Bubble Sort is O(n^2) in the worst case, where "n" is the number of elements in the list.

Let's break down the time complexity analysis:

The outer loop runs for "n" iterations, where "n" is the number of elements in the list.
The inner loop also runs for "n" iterations in the worst case. However, as the algorithm progresses, the number of iterations in the inner loop decreases, as the largest unsorted element gets placed at its correct position in each pass.
In the worst case, the number of comparisons and swaps is proportional to the square of the number of elements in the list, resulting in the O(n^2) time complexity. This makes Bubble Sort inefficient for large datasets, and more advanced sorting algorithms with better time complexities are often preferred in real-world applications.

Conclusion

In this article, we explored the concept of Bubble Sort, a simple sorting algorithm that repeatedly compares and swaps adjacent elements until the entire list is sorted. We provided a Python implementation of Bubble Sort, ran it with a sample list, and analyzed the output. Additionally, we discussed the time complexity of Bubble Sort, highlighting its O(n^2) worst-case time complexity and its implications for efficiency.

Next TopicLogging in Python

← prev next →