Implementación de cubos para los números de punto flotante en Python

Introducción a los números de puntos flotantes

El tipo de cubo es un algoritmo de clasificación basado en la distribución que divide los datos de entrada en un número finito de “boquetes” y luego clasifica el contenido de cada cubo individualmente. Cuando se aplica a los números de puntos flotantes que se distribuyen uniformemente a lo largo de un intervalo conocido — típicamente — tipo de cubo puede lograr la complejidad lineal del tiempo de caso promedio, lo que lo hace un candidato fuerte para las tareas de clasificación de alto rendimiento.

La idea central es simple: en lugar de comparar cada par de elementos (como en comparación se clasifica como un surtido rápido o un surtido de fusión), el tipo de cubo distribuye primero los elementos a través de cubos basados en sus valores. Cada cubo agrupa naturalmente un rango estrecho de valores. Después de eso, un algoritmo de clasificación simple - a menudo la inserción ordena o incluso una llamada recursiva a balde tipo - termina el trabajo.

Este artículo proporciona una mirada detallada a la implementación de la cubeta para números flotantes en Python, cubriendo sus mecánicas, complejidad, fortalezas, trampas y aplicaciones del mundo real.

Cómo funciona el cinturón

El tipo de cubo supone que la entrada se distribuye uniformemente dentro de un rango conocido, típicamente . El algoritmo procede en tres fases:

1. Initialization]: Crear una matriz de n cubos vacíos, donde n es el número de elementos.
2. ]Distribución: Por cada elemento , computar su índice de cubo ] (asumiendo que los valores están en ) y colocar el elemento en ese cubo.
3. Sorting and Concatenation: Clasificar cada cubo individualmente (utilizando cualquier tipo interno estable o eficiente), luego concatenar los cubos para producir el array final clasificado.

La clave es que debido a que los datos se distribuyen de forma uniforme, cada cubo recibe aproximadamente n / n = 1 elemento en promedio. Eso mantiene el costo de clasificar cubos individuales extremadamente bajo — a menudo tiempo constante por cubo.

Manejo de los casos de borde

Cuando un número de punto flotante es exactamente igual a 1.0, el índice calculado sería , que está fuera de límites. Un arreglo común es fijar el índice a para tales valores. En la práctica, si sus datos son estrictamente , este caso de borde no ocurre, pero es prudente guardar contra él.

Implementación de cubos Ordenar en Pitón

A continuación se muestra una aplicación limpia y lista para la producción de cubos para los números de puntos flotantes en el rango .

def bucket_sort(arr):
 """Sort an array of floats uniformly distributed in [0, 1)."""
 n = len(arr)
 if n <= 1:
 return arr

 # Create empty buckets
 buckets = [[] for _ in range(n)]

 # Distribute elements into buckets
 for num in arr:
 index = int(num * n)
 # Guard against floating-point index = n (e.g., when num == 1.0)
 if index == n:
 index = n - 1
 buckets[index].append(num)

 # Sort each bucket and concatenate
 sorted_arr = []
 for bucket in buckets:
 sorted_arr.extend(sorted(bucket)) # Python's Timsort is efficient

 return sorted_arr

La función utiliza el incorporado de Python para ordenar cada cubo. Para cubos que son pequeños (típicamente 0–2 elementos), esto es muy rápido. Para uso de la producción, usted podría reemplazar con tipo de inserción para arribar incluso más abajo en cubos pequeños.

Hebilla para rangos arbitrarios

Si tus datos de punto flotante abarcan un rango distinto a , puedes normalizar los valores antes de la distribución. Los siguientes mapas de variación de cualquier rango :

def bucket_sort_scaled(arr, min_val=None, max_val=None):
 if not arr:
 return arr
 if min_val is None:
 min_val = min(arr)
 if max_val is None:
 max_val = max(arr)

 # Guard against identical values
 if max_val == min_val:
 return arr

 n = len(arr)
 buckets = [[] for _ in range(n)]

 for num in arr:
 # Normalize to [0, 1)
 normalized = (num - min_val) / (max_val - min_val)
 index = int(normalized * n)
 if index == n:
 index = n - 1
 buckets[index].append(num)

 sorted_arr = []
 for bucket in buckets:
 sorted_arr.extend(sorted(bucket))
 return sorted_arr

Esta versión es más general pero requiere conocer o calcular el rango. Funciona bien cuando la distribución de datos es aproximadamente uniforme dentro de ese rango.

Análisis de la complejidad

Comprender el costo computacional de la clase de cubo es esencial para decidir cuándo utilizarlo.

Complejidad del tiempo

• El mejor caso (datos distribuidos de forma uniforme): O(n + k), donde k es el número de cubos (generalmente n[FLT] [Tipo de distribución] [LT [LT] [LT] [8]
• Caso de promedio: O(n + n2/k)] si se utiliza la clase de inserción para cubos. Con k = n , esto se convierte O(n)].
• El peor caso: O(n2)] cuando todos los elementos caen en el mismo cubo. Esto ocurre cuando los datos no se distribuyen uniformemente o cuando el rango es muy pequeño en relación con el número de elementos.

def insertion_sort(arr):
 for i in range(1, len(arr)):
 key = arr[i]
 j = i - 1
 while j >= 0 and arr[j] > key:
 arr[j + 1] = arr[j]
 j -= 1
 arr[j + 1] = key

def bucket_sort_insertion(arr):
 n = len(arr)
 if n <= 1:
 return arr
 buckets = [[] for _ in range(n)]
 for num in arr:
 index = int(num * n)
 if index == n:
 index = n - 1
 buckets[index].append(num)
 sorted_arr = []
 for bucket in buckets:
 insertion_sort(bucket)
 sorted_arr.extend(bucket)
 return sorted_arr