เพิ่มรูปแบบบัคเก็ตสําหรับหมายเลขจุดลอยใน Python

แนะนําการเรียงลําดับของบัคเก็ตสําหรับหมายเลขทศนิยม

Bucket เรียงลําดับเป็นอัลกอริทึมการเรียงลําดับแบบกระจาย ที่จัดจําหน่ายข้อมูลเข้าเป็นจํานวนจํากัด "ลูกกลม" และแยกเนื้อหาของแต่ละถังออกจากกัน เมื่อนําไปใช้กับตัวเลขจุดลอยที่กระจายตัวตามรูปแบบที่รู้จักกันทั่วไปคือ [FLT: 0] — ประเภทถังสามารถประสบความซับซ้อนแบบเชิงเส้นแบบเวลาเฉลี่ย ทําให้เป็นผู้สมัครที่แข็งแรงในการเรียงลําดับงาน

ใน ที่ สุด ถัง เหล่า นี้ จะ ถูก เรียง เป็น แถว เพื่อ เรียง เรียง เรียง ลําดับ กัน อย่าง เป็น ระบบ

บทความนี้แสดงให้เห็นเนื้อหาการประกอบถัง สําหรับการจัดรูปแบบการลอยของตัวเลขใน Python, ครอบคลุมกลไก, ความซับซ้อน, ความแข็งแกร่ง, กับดัก, และโปรแกรมโลกแห่งความเป็นจริง

วิธีที่บัคเก็ตทํางาน

บัคเก็ตเรียงลําดับสมมุติว่าการป้อนได้มีการกระจายตัวแบบสม่ําเสมอภายในช่วงที่รู้จักโดยทั่วไป [FLT: 1]. อัลกอริทึมที่ดําเนินการในสามระยะ:

1. [FLT: 0] การแบ่งประเภท : สร้างลําดับของ en ตะกร้าเปล่า (FLT:4] en เป็นจํานวนธาตุ
2. [FLT: 0]. discribusion: สําหรับแต่ละองค์ประกอบ คํานวณดัชนีถัง [ค่านิยมเชิงซ้อนอยู่ใน และวางธาตุลงในถังนั้น.
3. [FLT: 0] การจัดวางและการประกอบสวน : การจัดเรียงแต่ละถัง (ใช้แบบคงที่หรือมีประสิทธิภาพภายใน) จากนั้นประกอบถังเพื่อผลิตอาร์เรย์สุดท้าย (พ.ศ.

การ ทํา เช่น นี้ ทํา ให้ ราคา ของ การ แยก ถัง แต่ ละ ใบ ต่ํา มาก — บ่อย ครั้ง คงที่ ต่อ ถัง หนึ่ง ถัง.

แก้ไขโครงการหลัก...

เมื่อเลขทศนิยมเท่ากับ 1.0 ดัชนีการคํานวณจะเป็น [FLT: 5] ซึ่งอยู่นอกเหนือขอบเขต การแก้ไขทั่วไปคือ clamp ดัชนี [FLT: 6] สําหรับค่าดังกล่าว ในการฝึก หากข้อมูลของคุณเข้มงวด [FLT: 7] คดีนี้ไม่ได้เกิดขึ้น แต่ฉลาดที่จะรักษาไว้

การ เติม บัคเก็ต ให้ เต็ม

ด้านล่างนี้เป็นอุปกรณ์สําหรับผลิตแบบแบบแบบวางแผงสําหรับวางจุดลอยตัวในช่วง [FLT: 8].

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 ที่สร้างขึ้น [FLT: 10] เพื่อแยกถังแต่ละใบ สําหรับถังที่เล็ก (โดยปกติ 0-12) นี่เป็นพลังงานที่เร็วมาก สําหรับการผลิต คุณอาจจะแทนที่ (FLT: 11) ด้วยการแทรกสําหรับค่าหัวต่ําลงบนถังเล็ก ๆ

จัดเรียงปุ่มสําหรับช่วงของช่องสี

หากข้อมูลแบบลอยของคุณสแปนช่วงอื่น ๆ [FLT: 12] คุณสามารถปรับค่าได้ก่อนจัดจําหน่าย โดยค่าต่อไปนี้จะโยง [FLT: 13] ช่วง [FLT: 12] ไปยัง [FLT: 14]:

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

รุ่นนี้โดยทั่วไปกว่า แต่ต้องใช้ความรู้หรือคํานวณช่วง, มันใช้ได้ดีเมื่อการกระจายตัวข้อมูลประมาณ

การวิเคราะห์ความซับซ้อน

การ เข้าใจ ค่า ใช้ จ่าย ใน การ คํานวณ ของ ถัง เป็น สิ่ง จําเป็น เพื่อ จะ ตัดสิน ใจ ว่า จะ ใช้ เมื่อ ไร.

ความซับซ้อนของเวลา

• [FLT: 0]. [FLTT:1] [ข้อมูล] [FLT]] O[n+k]] โดย[FLTTT:4] k[FTTTT:1] เป็นจํานวนถัง (ปกติ[FLTT:1] [FLT]] [FLT]]. สืบค้นเมื่อ ค.ศ.
• [FLT: 0] เคส ]: O(n+n2/k] ] ] ถ้าใช้การแทรกเรียงสําหรับถัง. กับ[FLTT: 4] k= n[FLT: 5] นี่กลายเป็น [FLTT: 6] (FN] (FLT) (F) (FLT: ⁇ ).
• [FLT: 0]. เคส]: O(n2]] เมื่อธาตุทั้งหมดตกถังเดียวกัน เหตุการณ์นี้เกิดขึ้นเมื่อข้อมูลไม่กระจายตัวแบบสม่ําเสมอ หรือในช่วงที่เล็กมากเมื่อเทียบกับจํานวนธาตุ

ความซับซ้อนของช่องว่าง

Bucket scheme ต้องการ [[FLT: 0] O(n+k)[FLT: 1) ช่องพิเศษสําหรับถังและส่วนต่าง ๆ ของพวกเขา โดยมี k= (FLT:3]] นี้คือ[FLT: 4] O (n)[FLT: 5] ช่องที่ใช้เมื่อเทียบกับการรวมของตัวพิมพ์ใหญ่และสูงกว่าที่นิยมใช้ในเร็ว ๆ นี้

• [FLT: 0] การแปรรูปการเข้า : ถ้าข้อมูลถูกเบ้ (เช่น ค่าส่วนใหญ่รวมกันเข้าด้วยกัน), ธาตุส่วนใหญ่ตกเป็นถังไม่กี่ถัง เพิ่มค่าใช้จ่ายในการเรียงลําดับ O(n). .
• [FLT: 0]. สืบค้นข้อมูลก่อนหน้าความรู้ช่วง: หากไม่รู้ค่าต่ําสุดและสูงสุด คุณไม่สามารถสร้างถังได้สําเร็จ. รุ่นที่ยืดออกเหนือขึ้นไปนี้ แต่การคํานวณช่วงเพิ่มการผ่าน
• [FLT: 0] รายการ Python สามารถบริโภคหน่วยความจําที่สําคัญได้ โดยเฉพาะอาร์เรย์ขนาดใหญ่ เชื่อมโยงรายการหรืออาร์เรย์สามารถลดค่าใช้จ่ายได้ แต่รายการของ Python นั้นตรงไปตรงมา
• [FLT: 0] โอเวอร์เฮดของ schepeding ต่อตัว : การแยกถังเล็ก ๆ หลายใบที่มี Python ฟังก์ชันที่เรียกรวมเข้าด้วยกัน สําหรับถังเล็กมากๆ แบบแทรกอาจเร็วกว่า

เมื่อไม่ได้ใช้งานบัคเก็ตเรียงลําดับ

หลีกเลี่ยงการเรียงลําดับของถังเมื่อข้อมูลไม่ได้กระจายตัวแบบสม่ําเสมอ เมื่อช่วงมีมากเมื่อเทียบกับจํานวนธาตุ หรือเมื่อหน่วยความจําถูกจํากัดมาก

เทียบ กับ อัล กอ ทิก ที่ คัด เลือก ชนิด อื่น

บัคเก็ตใช้รูปแบบเฉพาะในการเรียงลําดับอัลกอริทึม นี่คือวิธีการเปรียบเทียบกับตัวเลือกทั่วไป:

สําหรับเลขจุดลอย, การเรียงลําดับถังมักจะออกผล radix เรียงลําดับ (ซึ่งต้องใช้บิตการจัดรูปของลอย) และสามารถเร็วกว่า O (n Llog n) [FLT: 1) ชนิดเมื่อข้อมูลอยู่ในเครื่องแบบ

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