Toteutus Bucket Järjestä kelluva piste numerot Python

Johdanto Bucket Järjestä kelluva piste numerot

Bucket lajittelee on jakelupohjainen lajittelualgoritmi, joka jakaa syötetiedot finite määrä . Buckets. Ja sitten lajittele sisältö kunkin kauhan erikseen. Kun sovelletaan kelluva-piste numerot, jotka ovat tasaisesti jaettu yli tunnetun ajan . tyypillisesti ... kauha laji voi saavuttaa lineaarisen keskimääräinen-tapaus aika monimutkaisuutta, joten se on vahva ehdokas korkean suorituskyvyn lajittelutehtäviä.

Ydin idea on yksinkertainen: sen sijaan, että vertailtaisiin jokaista paria elementtejä (kuten quicksort tai combinationssort), kauha lajittelee ensin jakaa elementtejä kauhojen perustuu niiden arvoja. Jokainen kauha luonnollisesti ryhmittyy yhteen kapea valikoima arvoja. Sen jälkeen yksinkertainen lajittelu algoritmi . Usein insertin lajittele tai jopa rekursiivinen puhelu kauha lajittelee . Lopuksi kauhat ovat concatenated jotta tuottaa lajiteltu sarja.

Tämä artikkeli tarjoaa perusteellisen tarkastelun toteuttaa kauha lajittelemaan kelluva piste numerot Python, joka kattaa sen mekaniikka, monimutkaisuus, vahvuudet, sudenkuoppia, ja reaalimaailman sovelluksia.

Miten Bucket-lajittelu toimii

Ämpärityyppi olettaa, että panos jakautuu tasaisesti tunnetulle alueelle, tyypillisesti . Algoritmi etenee kolmessa vaiheessa:

1. initialisointi[: Luo joukko []n tyhjiä kauhoja, joissa n on elementtien määrä.
2. Jakaminen[: Kunkin elementin osalta lasketaan sen kauhaindeksi (oletusarvot ovat ) ja sijoitetaan elementti kyseiseen ämpäriin.
3. Lajittelu ja koncataatio[: Lajittele jokainen ämpäri erikseen (käyttäen mitä tahansa vakaata tai tehokasta sisäistä lajittelemista), sitten yhdistä ämpärit tuottaaksesi lopullisen lajitellun sarjan.

Avainnäkymä on, että koska tiedot ovat tasaisesti jaettu, jokainen kauha saa karkeasti ]n / n = 1[ elementti keskimäärin. Tämä pitää kustannukset lajittelun yksittäisten kauhojen erittäin alhainen .

Edge-tapausten käsittely

Kun kelluva pisteluku on täsmälleen 1,0, laskennallinen indeksi olisi , joka on rajojen ulkopuolella. Yhteinen korjaus on pihkata indeksi [ tällaisia arvoja. Käytännössä, jos tiedot ovat tiukasti , tämä reuna tapauksessa ei tapahdu, mutta se on viisasta vartioida sitä.

Toteutus Bucket Sort Python

Alla on puhdas, tuotantovalmis implementointi kauha lajittelemalla kelluva piste numerot alueella .

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

Funktio käyttää Python...-sinä sisäänrakennettua -ämpäriä kunkin kauhan lajitteluun. Pienille (tyypillisesti 0...2 elementtiä) kauhoille tämä on hyvin nopeaa. Tuotannossa voit korvata lisäämällä vieläkin alemman yläpuolen pienille kauhoille.

Ämpäri Järjestä Mielivaltaiset Range-alueet

Jos kelluva pistetietosi ovat muun kuin -alueen välillä, arvot voidaan normalisoida ennen jakelua. Seuraavat vaihtelukartat ovat -alueella :

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

Tämä versio on yleisempi, mutta vaatii alueen tuntemista tai laskentaa. Se toimii hyvin, kun tiedon jakelu on suunnilleen yhdenmukaista tällä alueella.

Kompleksisuusanalyysi

Ymmärtäminen laskentakustannusten kauha laji on välttämätöntä päätettäessä, milloin käyttää sitä.

Aikakompleksisuus

• Paras tapaus[ (yhtenäisesti jaetut tiedot): []O(n + k)[], jossa []k[] on ämpärien lukumäärä (yleensä ]n[[]]). Jakelu on O(n)[[]], ja kunkin kauhan lajittelu kestää keskimäärin niin paljon aikaa O(n][[[]].
• ]Keskimmäinen tapaus[: ]O(n + n2/k)[], jos käytetään ämpäreihin lisättävää lajittelevaa. ]k = n[], tästä tulee []O(n][[]].
• Pahin tapaus[: O(n2)[], kun kaikki elementit putoavat samaan kauhaan. Tämä tapahtuu silloin, kun tietoja ei jakautunut tasaisesti tai kun vaihteluväli on hyvin pieni suhteessa osien määrään.

Space Complexity

Ämpärityyppi vaatii ]O(n + k)[] lisätilaa kauhoille ja niiden sisällöille. k = n[]], tämä on ]O[n][[]]]. Käytetty tila on verrattavissa quicksortin kaltaisiin yhdistelmiin ja korkeampiin.

Edut ja käyttötapaukset

Ämpärityyppi loistaa erityisissä skenaarioissa, joissa sen oletukset ovat:

• Uniformaalisesti jaetut kelluvat pistetiedot[ .
• Suuri tietoaineisto ... ...................................................................................................................................................................................................................................
• Ulkoinen lajittelu[ . Kun tiedot sijaitsevat levyllä, kauhat voidaan käsitellä itsenäisesti ja kirjoittaa eri tiedostoja, sitten concatenated.
• Parallel ja GPU computing[ . Jokainen kauha voidaan lajitella itsenäisesti, jolloin massiivinen rinnakkaisuus.

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