Visualizing Bubble sort using Python

Visualizing Bubble Sort with Python

Understanding sorting algorithms can be challenging, but visualizing their operations makes the learning process more intuitive. In this guide, we'll explore how to animate the Bubble Sort algorithm using Python's Matplotlib library, providing a clear and engaging way to grasp its mechanics.

What Is Bubble Sort?

Bubble Sort is a simple comparison-based sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This process continues until the list is sorted. Despite its simplicity, Bubble Sort is inefficient on large lists and generally performs worse than the well-known algorithms like quicksort and merge sort.

Setting Up the Environment

Before we begin, ensure you have Python installed along with the necessary libraries. You'll need:

pip install numpy matplotlib

These libraries will help us generate the data and create the animations.

Implementing Bubble Sort with Visualization

We'll create a function to perform Bubble Sort and record the state of the list after each pass. This allows us to visualize the sorting process step by step.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

def bubble_sort_visualize(arr):
    states = [arr.copy()]
    for i in range(len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
            states.append(arr.copy())
    return states

arr = np.random.randint(1, 100, 50)
states = bubble_sort_visualize(arr)

fig, ax = plt.subplots()
bar_rects = ax.bar(range(len(arr)), states[0], align="edge")
ax.set_xlim(0, len(arr))
ax.set_ylim(0, 100)

def update_fig(frame, bar_rects, states):
    for rect, h in zip(bar_rects, states[frame]):
        rect.set_height(h)
    return bar_rects

ani = animation.FuncAnimation(fig, update_fig, frames=len(states), fargs=(bar_rects, states), interval=50, repeat=False)
plt.show()

This code creates a bar chart that updates with each frame, showing the progression of the Bubble Sort algorithm.

Enhancing the Visualization

To make the visualization more informative, you can add labels to indicate the number of operations performed and highlight the elements being compared or swapped. This provides a clearer understanding of the algorithm's behavior at each step.

Conclusion

Visualizing algorithms like Bubble Sort can significantly enhance your understanding of their operations. By animating the sorting process, you can observe how the algorithm progresses and how elements are moved, making the learning experience more engaging and effective.