# Bucket Sort

## Introduction to Bucket Sort

Bucket Sort is a non-comparison based sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket is then sorted individually, either using a different sorting algorithm or applying the bucket sort algorithm recursively. Finally, the sorted values are gathered from the buckets to produce the sorted output.

The performance of bucket sort depends on how well the input data is distributed across the buckets. If the data is evenly distributed, bucket sort can achieve a linear time complexity of O(n). However, if the data is poorly distributed, the time complexity can be as bad as O(n²), where n is the number of elements in the array.

## Real-world Examples and Scenarios of Bucket Sort

Bucket sort is particularly useful when the input data can be easily divided into a fixed number of groups. Here are some real-world examples and scenarios where bucket sort can be used effectively:

**Sorting exam scores**: Imagine you have a list of exam scores ranging from 0 to 100. You can use bucket sort to sort the scores by dividing them into 10 buckets, each representing a range of 10 scores (0-9, 10-19, 20-29, ... , 90-100). Since the scores are evenly distributed, the sorting process will be efficient.

**Sorting colors in an image**: If you have an image and you want to sort its colors based on their intensities, you can use bucket sort to achieve this. Divide the colors into a number of buckets based on their intensity levels, sort each bucket, and then merge the buckets to get the sorted colors.

**Sorting sensor data**: In a sensor network, you might have sensors that produce data with a known and limited range of values. You can use bucket sort to sort the sensor data efficiently.

## Real-world Scenario and Technical Problem

Consider a weather station that collects daily temperature data for a city and stores it in an array. The temperature values range from -50 to 50 degrees Celsius. The weather station wants to find the median temperature for the past 30 days.

To solve this problem, we can use bucket sort to sort the temperature data, and then find the median value from the sorted data.

## Problem Statement and Formal Definition

Given an array of integers `temperatures`

representing the daily temperatures for the past 30 days, and the range of possible temperatures `-50 <= temperatures[i] <= 50`

, sort the array and find the median temperature.

## Tying the Problem Statement with the Real-world Scenario

In the given real-world scenario, the weather station needs to find the median temperature for the past 30 days. By sorting the temperature data using bucket sort, we can efficiently find the median value, which will help the station in making better predictions and analyses.

## Solution to the Problem

To solve this problem, we will follow these steps:

- Create a fixed number of buckets, each representing a range of temperature values.
- Distribute the temperature data into the corresponding buckets.
- Sort each bucket individually.
- Merge the sorted buckets to produce the sorted temperature data.
- Find the median value from the sorted data.

## Step-by-step Solution with the Real-world Scenario

First, we will create 10 buckets, each representing a range of 10 temperature values (for example, -50 to -41, -40 to -31, ..., 40 to 50).

Next, we will distribute the daily temperature data into the corresponding buckets. For example, if the temperature of a day is -25 degrees, it will go into the third bucket representing the range -30 to -21.

After distributing the data, we will sort each bucket individually. We can use insertion sort or any other suitable sorting algorithm for this purpose.

Once all buckets are sorted, we will merge them to produce the sorted temperature data.

Finally, we will find the median value from the sorted data. Since we have 30 days of data, the median value will be the average of the 15th and 16th values in the sorted array.

## Actual Code Solution with High-level Comments

```
def bucket_sort(temperatures):
# Initialize the buckets
buckets = [[] for _ in range(10)]
# Distribute the temperature data into the corresponding buckets
for temp in temperatures:
index = (temp + 50) // 10
buckets[index].append(temp)
# Sort each bucket individually
for bucket in buckets:
bucket.sort()
# Merge the sorted buckets to produce the sorted temperature data
sorted_temps = []
for bucket in buckets:
sorted_temps.extend(bucket)
return sorted_temps
def find_median(sorted_temps):
n = len(sorted_temps)
if n % 2 == 0:
return (sorted_temps[n // 2 - 1] + sorted_temps[n // 2]) / 2
else:
return sorted_temps[n // 2]
# Example temperature data for the past 30 days
temperatures = [0, 10, -5, 20, -10, 5, 30, 15, -20, 25, -30, 35, -40, 45, 50, -35, -45, 40, 49, -50, 10, 20, 30, -40, -50, 50, 40, 30, 20, 10]
# Sort the temperature data using bucket sort
sorted_temps = bucket_sort(temperatures)
# Find the median temperature
median_temp = find_median(sorted_temps)
print("Sorted temperatures:", sorted_temps)
print("Median temperature:", median_temp)
```

## Explanation of the Code Solution with Intuitions and Analogies

The bucket sort algorithm works by dividing the input data into a fixed number of groups or "buckets". In our case, we have created 10 buckets to represent the range of temperatures from -50 to 50 degrees Celsius. Each bucket represents a range of 10 temperature values.

We then distribute the daily temperature data into the corresponding buckets based on their values. For example, if a temperature value is -25, it will go into the third bucket representing the range -30 to -21.

After distributing the data, we sort each bucket individually. This is similar to sorting small piles of data separately, which is more efficient than sorting the entire data at once. Once all the buckets are sorted, we merge them to produce the sorted temperature data.

Finally, we find the median value from the sorted data. In our case, the median value is the average of the 15th and 16th values in the sorted array.

## How the Solution Can Solve Other Similar Real-world Problems

This solution can be applied to other similar real-world problems where the input data can be easily divided into a fixed number of groups. Some examples include:

- Sorting exam scores or grades.
- Sorting colors in an image based on their intensities.
- Sorting sensor data with a known and limited range of values.

By using bucket sort in these scenarios, we can achieve efficient sorting and solve the problems at hand.