Python桶排序原理与实现详解

def bucket_sort(arr, bucket_size=5):
    """
    桶排序算法实现
    参数:
    arr: 待排序的数组
    bucket_size: 每个桶的大小范围，默认值为5
    返回:
    排序后的数组
    """
    if len(arr) == 0:
        return arr
    # 步骤1：确定数据的最大值和最小值
    min_value = min(arr)
    max_value = max(arr)
    # 步骤2：计算需要的桶数量
    bucket_count = (max_value - min_value) // bucket_size + 1
    buckets = [[] for _ in range(bucket_count)]
    # 步骤3：将数据分配到各个桶中
    for i in range(len(arr)):
        # 计算当前元素应该放入哪个桶
        index = (arr[i] - min_value) // bucket_size
        buckets[index].append(arr[i])
    # 步骤4：对每个桶进行排序（这里使用内置排序，也可用其他排序算法）
    for i in range(bucket_count):
        buckets[i].sort()
    # 步骤5：将排序后的桶按顺序合并
    sorted_arr = []
    for bucket in buckets:
        sorted_arr.extend(bucket)
    return sorted_arr
# 测试示例
if __name__ == "__main__":
    # 测试数据1：均匀分布的整数
    test_data1 = [29, 25, 3, 49, 9, 37, 21, 43]
    print("原始数据:", test_data1)
    sorted_data1 = bucket_sort(test_data1)
    print("桶排序结果:", sorted_data1)
    # 测试数据2：包含小数的数据
    test_data2 = [0.42, 0.32, 0.33, 0.52, 0.37, 0.47, 0.51]
    print("
原始数据:", test_data2)
    sorted_data2 = bucket_sort(test_data2, bucket_size=0.1)
    print("桶排序结果:", sorted_data2)

def grade_sort(grades):
    """学生成绩桶排序示例"""
    buckets = [[] for _ in range(11)]  # 11个桶对应0-100分
    for grade in grades:
        bucket_index = grade // 10
        buckets[bucket_index].append(grade)
    # 对每个桶排序
    for bucket in buckets:
        bucket.sort()
    # 合并结果
    return [grade for bucket in buckets for grade in bucket]
# 测试成绩排序
grades = [85, 92, 78, 65, 95, 88, 72, 60, 98, 83]
sorted_grades = grade_sort(grades)
print(f"原始成绩: {grades}")
print(f"排序后成绩: {sorted_grades}")

def float_bucket_sort(floats):
    """浮点数桶排序"""
    min_val = min(floats)
    max_val = max(floats)
    
    # 创建10个桶
    bucket_count = 10
    buckets = [[] for _ in range(bucket_count)]
    
    # 分配数据到桶中
    for num in floats:
        index = int((num - min_val) / (max_val - min_val) * (bucket_count - 1))
        buckets[index].append(num)
    
    # 桶内排序并合并
    result = []
    for bucket in buckets:
        bucket.sort()
        result.extend(bucket)
    
    return result

def adaptive_bucket_sort(arr):
    """自适应桶大小的桶排序"""
    if not arr:
        return arr
    
    min_val, max_val = min(arr), max(arr)
    range_val = max_val - min_val
    
    # 根据数据范围自适应确定桶数量
    if range_val < 100:
        bucket_size = 10
    elif range_val < 1000:
        bucket_size = 100
    else:
        bucket_size = range_val // 100
    
    return bucket_sort(arr, bucket_size)

def recursive_bucket_sort(arr, bucket_size=5, depth=0, max_depth=3):
    """递归桶排序，防止桶内数据过多"""
    if len(arr) <= 1 or depth > max_depth:
        return sorted(arr)
    
    min_val, max_val = min(arr), max(arr)
    bucket_count = (max_val - min_val) // bucket_size + 1
    buckets = [[] for _ in range(bucket_count)]
    
    for num in arr:
        index = (num - min_val) // bucket_size
        buckets[index].append(num)
    
    result = []
    for bucket in buckets:
        if len(bucket) > 10:  # 如果桶内元素过多，递归排序
            sorted_bucket = recursive_bucket_sort(bucket, bucket_size, depth + 1, max_depth)
        else:
            sorted_bucket = sorted(bucket)
        result.extend(sorted_bucket)
    
    return result