Bộ cánh phù hợp với số điểm nổi trong Python

Điều quan trọng là vì dữ liệu được phân phối đồng đều, mỗi xô nhận được một yếu tố [FLT: 0], và trung bình mỗi xô đều có giá của mỗi xô phân loại rất thấp, thường là thời gian liên tục trên một xô.

Xử lý các vụ án cạnh

Khi một con số nổi chính xác bằng 1.0, chỉ số tính toán sẽ , không có giới hạn. Một sửa chữa thường xuyên là kẹp cho các giá trị như thế. Trong thực tế, nếu dữ liệu của bạn là hoàn toàn , thì điều này không xảy ra, nhưng nên thận trọng để tránh nó.

Bộ cánh nhỏ được giải mã bằng Python

Dưới đây là một loại sạch, sản xuất sẵn sàng thực hiện xô cho số điểm nổi trong phạm vi .

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

Chức năng này dùng các vật liệu được xây dựng của Python để sắp xếp mỗi xô, để có các xô nhỏ (thường là 0–2), rất nhanh.

Bộ cánh thích hợp cho phạm vi bộ phận cắt

Nếu dữ liệu điểm nổi của bạn có thể trải qua một phạm vi khác , bạn có thể bình thường hóa các giá trị trước khi phân phối. Các biến thể sau đây sẽ vẽ phạm vi :]:

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

Phiên bản này thông thường hơn nhưng yêu cầu sự hiểu biết hoặc tính toán phạm vi. nó hoạt động tốt khi phân phối dữ liệu gần như đồng nhất trong phạm vi đó.

Phân tích độ phức tạp

Hiểu được giá cả của việc sử dụng các loại xô là điều thiết yếu để quyết định khi nào nên sử dụng.

Độ phức tạp thời gian

• [FLT:] trường hợp ) [không được phép phân phối dữ liệu]: [FLT:] [không được chuẩn [FLT:]] [không được phân phối]] là số xô [thường .].
• trường hợp ): : [n + n2/k] nếu dùng chất chèn cho xô. k = n , điều này sẽ trở thành [FLT: 6] [FLT: 6] [FLT:]] [FLT: 7].
• trường hợp ):]: [FLT:] khi mọi nguyên tố rơi vào cùng một xô. Điều này xảy ra khi dữ liệu không được phân phối đồng đều hoặc khi phạm vi rất nhỏ so với số nguyên tố.

Độ phức tạp không gian

Kiểu Bucket đòi hỏi O [n + k] [FLT: 1] [N: 1] [N] thêm chỗ cho xô và nội dung của chúng. Với k = n [FLT:], đây là [N] [N] [FLT:] [FLT:] [FL: 5]]] [FL:]]. Không gian được dùng để tương ứng với sự kết hợp giữa các khoảng và cao hơn là dạng của các loại nhanh chóng.

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