# 7.3 Bubble Sort Algorithm| Data Structures Tutorials

## Table of Contents

## Introduction

This tutorial covers the Bubble Sort algorithm, a fundamental sorting technique used in computer science. We'll explore how it works, its implementation in code, and analyze its time complexity in both the best and worst cases. Understanding Bubble Sort is essential for grasping more complex sorting algorithms and data structures.

## Step 1: Understanding the Bubble Sort Algorithm

Bubble Sort is a simple comparison-based sorting algorithm. It repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The process is repeated until the list is sorted.

### Key Features

**Comparison-based**: Elements are compared in pairs.**In-place sorting**: It doesn't require additional storage.**Stable sorting**: It maintains the relative order of equal elements.

### How It Works

- Start at the beginning of the list.
- Compare the first two adjacent elements.
- If the first element is greater than the second, swap them.
- Move to the next pair and repeat until the end of the list.
- Repeat the entire process until no swaps are needed.

## Step 2: Implementing Bubble Sort in Code

Here’s a basic implementation of Bubble Sort in Python:

```
def bubble_sort(arr):
n = len(arr)
# Traverse through all array elements
for i in range(n):
# Last i elements are already sorted
for j in range(0, n-i-1):
# Traverse the array from 0 to 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
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("Sorted array is:", arr)
```

### Practical Tips

- Use this algorithm for small datasets where simplicity is preferred over efficiency.
- For larger datasets, consider more advanced sorting algorithms.

## Step 3: Analyzing Time Complexity

Understanding the efficiency of Bubble Sort is crucial. The time complexity is determined by how many comparisons and swaps are made.

### Best Case

- The best-case scenario occurs when the list is already sorted.
**Time Complexity**: O(n) – only one pass is made through the array.

### Worst Case

- The worst-case scenario happens when the list is sorted in reverse order.
**Time Complexity**: O(n^2) – comparisons are made for each element.

### Average Case

- The average case also results in O(n^2) as it requires multiple passes through the list.

## Conclusion

Bubble Sort is an easy-to-understand sorting algorithm suitable for educational purposes and small datasets. Remember its simplicity comes at the cost of efficiency, making it less ideal for larger datasets. For further learning, explore more advanced algorithms like Quick Sort or Merge Sort. Implementing these algorithms will enhance your understanding of sorting mechanisms in data structures.