Python의 부동점 수에 대한 버킷 정렬 구현

Floating-Point Numbers에 대한 Bucket Sort 소개

버킷 종류는 “버켓”의 무한 숫자로 입력 데이터를 분할하고 개별적으로 각 버킷의 내용을 정렬하는 분산 된 분산 알고리즘입니다. 일반적으로 알려진 간격을 통해 균일하게 배포되는 부동점 번호에 적용 할 때 - 일반적으로 - 버킷 종류는 선형 평균 케이스 시간 복잡성을 달성 할 수 있으며 고성능 정렬 작업을 위해 강력한 후보자를 만들 수 있습니다.

이 웹 사이트는 귀하가 웹 사이트를 탐색하는 동안 귀하의 경험을 향상시키기 위해 쿠키를 사용합니다. 이 쿠키들 중에서 필요에 따라 분류 된 쿠키는 웹 사이트의 기본적인 기능을 수행하는 데 필수적이므로 브라우저에 저장됩니다. 또한이 웹 사이트의 사용 방식을 분석하고 이해하는 데 도움이되는 제 3 자 쿠키를 사용합니다. 이 쿠키는 귀하의 동의하에 만 브라우저에 저장됩니다. 이러한 쿠키를 거부 할 수도 있습니다. 이러한 쿠키 중 일부를 선택 해제하면 검색 환경에 영향을 미칠 수 있습니다.

이 문서는 Python의 부동점 숫자를 구현하는 심층적 인 모습을 제공하여 기계, 복잡성, 힘, pitfalls 및 실제 응용 프로그램을 덮고 있습니다.

버킷 정렬 작업

Bucket 정렬은 일반적으로 알려진 범위 내에서 균일하게 배포되는 것을 가정한다 . 알고리즘은 3 단계로 진행한다.

1. Initialization: ]n] 빈 버킷의 배열을 생성, 어디 n]]의 숫자 요소입니다.
2. Distribution: 각 원소 를 위해, 버킷 인덱스 를 계산합니다 (값을 ]) 그리고 그 버킷에 요소를 배치합니다.
3. Sorting and Concatenation: 각 버킷을 개별적으로 정렬(무연 또는 효율적인 내부 정렬), 그 후 최종 정렬 배열을 생성하기 위해 버킷을 계속합니다.

데이터가 균일하게 배포되기 때문에 주요 통찰력은 각 버킷은 대략 n / n = 1] 평균에 대한 요소가 표시됩니다. 즉, 개인 버킷을 매우 낮게 분류하는 비용을 유지 - 버킷 당 일정한 시간을 유지합니다.

Edge 케이스 처리

부동점 수가 1.0과 동일하면, 계산된 인덱스는 ]일 것입니다. 일반적인 수정은 같은 값에 대한 ]]에 인덱스를 클램핑하는 것입니다. 실제로 데이터가 엄격하게 ]인 경우, 이 가장자리 케이스가 발생하지 않지만, 반대가 발생하지 않습니다.

Python에서 Bucket Sort 구현

아래는 범위의 부동점 번호에 대한 버킷 정렬의 깨끗하고 생산 실습 구현 ].

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

함수는 Python의 내장 를 사용하여 각 버킷을 정렬합니다. 작은 (일반 0–2 요소) 인 버킷을 위해, 이것은 매우 빠릅니다. 생산용 사용의 경우, ]를 대신하여 작은 버킷에 더 낮은 오버 헤드를 위한 삽입 종류로 교체할 수 있습니다.

버킷 정렬 Arbitrary 범위

플로팅 포인트 데이터가 다른 범위에 걸쳐 , 당신은 배포하기 전에 값을 정상화 할 수 있습니다. 다음의 변형은 ] 범위에 어떤 를지도합니다:

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

이 버전은 더 일반적이지만 범위를 알고 또는 계산해야합니다. 데이터 배포가 그 범위 내에서 약 균일 할 때 잘 작동합니다.

공정성 분석

버킷의 계산 비용을 이해하는 것은 사용 할 때 결정에 필수적입니다.

시간 복잡성

• 최고의 경우(일부로 배포된 데이터):]O(n + k),]k]]은 버킷의 수 (n]). 배포는 O(n)[LT:9]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
• 평균 케이스: ]O(n + n2/k)] 버킷에 삽입 정렬을 사용하는 경우. k = n], 이것은 O(n).
• Worst case: O(n2)]] 모든 요소가 동일한 버킷으로 떨어질 때. 이 데이터가 제복할 때 또는 범위가 요소의 수에 매우 작은 상대적일 때 발생합니다.

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