Bøtte sortering er en sorteringsteknikk som går ut på å dele inn elementer i ulike grupper, eller bøtter. Disse bøttene dannes ved å fordele elementene jevnt. Når elementene er delt inn i bøtter, kan de sorteres ved hjelp av en hvilken som helst annen sorteringsalgoritme. Til slutt samles de sorterte elementene sammen på en ordnet måte.
Algoritme for bøttesortering:
Skape n tømme bøtter (eller lister) og gjør følgende for hvert matriseelement arr[i].
- Sett inn arr[i] i bøtte[n*array[i]]
- Sorter individuelle bøtter ved hjelp av innsettingssortering.
- Sammenknytt alle sorterte bøtter.
Hvordan fungerer Bucket Sort?
For å bruke bøttesortering på inndatamatrisen [0,78, 0,17, 0,39, 0,26, 0,72, 0,94, 0,21, 0,12, 0,23, 0,68] , følger vi disse trinnene:
Trinn 1: Lag en matrise med størrelse 10, der hvert spor representerer en bøtte.
Lage bøtter for sortering
Steg 2: Sett inn elementer i bøttene fra inndatamatrisen basert på rekkevidden deres.
Sette inn elementer i bøttene:
dele strenger c++
- Ta hvert element fra inndatamatrisen.
- Multipliser elementet med størrelsen på bøttegruppen (10 i dette tilfellet). For eksempel, for element 0,23, får vi 0,23 * 10 = 2,3.
- Konverter resultatet til et heltall, som gir oss bøtteindeksen. I dette tilfellet konverteres 2.3 til heltall 2.
- Sett elementet inn i bøtta som tilsvarer den beregnede indeksen.
- Gjenta disse trinnene for alle elementene i inndatamatrisen.
Sette inn Array-elementer i respektive bøtter
Trinn 3: Sorter elementene i hver bøtte. I dette eksemplet bruker vi quicksort (eller en hvilken som helst stabil sorteringsalgoritme) for å sortere elementene i hver bøtte.
Sortering av elementene i hver bøtte:
- Bruk en stabil sorteringsalgoritme (f.eks. Bubble Sort, Merge Sort) for å sortere elementene i hver bøtte.
- Elementene i hver bøtte er nå sortert.
Sortering av individuell bøtte
Trinn 4: Samle elementene fra hver bøtte og sett dem tilbake i den opprinnelige matrisen.
Samle elementer fra hver bøtte:
- Gå gjennom hver bøtte i rekkefølge.
- Sett hvert enkelt element fra bøtta inn i den originale matrisen.
- Når et element er kopiert, fjernes det fra bøtta.
- Gjenta denne prosessen for alle bøtter til alle elementene er samlet.
Sette inn bøtter i stigende rekkefølge i den resulterende matrisen
Trinn 5: Den opprinnelige matrisen inneholder nå de sorterte elementene.
Den endelige sorterte matrisen som bruker bøttesortering for den gitte inngangen er [0,12, 0,17, 0,21, 0,23, 0,26, 0,39, 0,68, 0,72, 0,78, 0,94].
Returner den sorterte matrisen
Implementering av bøttesorteringsalgoritme:
Nedenfor er implementeringen for Bucket Sort:
C++ #include #include using namespace std; // Insertion sort function to sort individual buckets void insertionSort(vector& bøtte) { for (int i = 1; i< bucket.size(); ++i) { float key = bucket[i]; int j = i - 1; while (j>= 0 && bøtte[j]> nøkkel) { bøtte[j + 1] = bøtte[j]; j--; } bøtte[j + 1] = nøkkel; } } // Funksjon for å sortere arr[] av størrelse n ved å bruke bøttesortering void bucketSort(float arr[], int n) { // 1) Lag n tomme bøttevektorb[n]; // 2) Plasser matriseelementer i forskjellige bøtter for (int i = 0; i< n; i++) { int bi = n * arr[i]; b[bi].push_back(arr[i]); } // 3) Sort individual buckets using insertion sort for (int i = 0; i < n; i++) { insertionSort(b[i]); } // 4) Concatenate all buckets into arr[] int index = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < b[i].size(); j++) { arr[index++] = b[i][j]; } } } // Driver program to test above function int main() { float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434}; int n = sizeof(arr) / sizeof(arr[0]); bucketSort(arr, n); cout << 'Sorted array is
'; for (int i = 0; i < n; i++) { cout << arr[i] << ' '; } return 0; }>
Java import java.util.ArrayList; import java.util.List; public class Main { // Insertion sort function to sort individual buckets public static void insertionSort(Listbøtte) { for (int i = 1; i< bucket.size(); ++i) { float key = bucket.get(i); int j = i - 1; while (j>= 0 && bucket.get(j)> key) { bucket.set(j + 1, bucket.get(j)); j--; } bøtte.sett(j + 1, nøkkel); } } // Funksjon for å sortere arr[] av størrelse n ved å bruke bøttesortering public static void bucketSort(float[] arr) { int n = arr.length; // 1) Opprett n tomme bøtteliste[] buckets = new ArrayList[n]; for (int i = 0; i< n; i++) { buckets[i] = new ArrayList(); } // 2) Put array elements in different buckets for (int i = 0; i < n; i++) { int bi = (int) (n * arr[i]); buckets[bi].add(arr[i]); } // 3) Sort individual buckets using insertion sort for (int i = 0; i < n; i++) { insertionSort(buckets[i]); } // 4) Concatenate all buckets into arr[] int index = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < buckets[i].size(); j++) { arr[index++] = buckets[i].get(j); } } } // Driver program to test above function public static void main(String[] args) { float[] arr = {0.897f, 0.565f, 0.656f, 0.1234f, 0.665f, 0.3434f}; bucketSort(arr); System.out.println('Sorted array is:'); for (float num : arr) { System.out.print(num + ' '); } } }> Python def insertion_sort(bucket): for i in range(1, len(bucket)): key = bucket[i] j = i - 1 while j>= 0 og bøtte[j]> nøkkel: bøtte[j + 1] = bøtte[j] j -= 1 bøtte[j + 1] = nøkkel def bucket_sort(arr): n = len(arr) bøtter = [[] for _ i område(n)] # Plasser array-elementer i forskjellige bøtter for num i arr: bi = int(n * num) buckets[bi].append(num) # Sorter individuelle buckets ved hjelp av insertion sort for bucket in buckets: insertion_sort (bøtte) # Sammenknytt alle bøttene til arr[] indeks = 0 for bøtte i bøtte: for num i bøtte: arr[indeks] = num indeks += 1 arr = [0,897, 0,565, 0,656, 0,1234, 0,6345, 40. (arr) print('Sortert matrise er:') print(' '.join(map(str, arr)))> C# using System; using System.Collections.Generic; class Program { // Insertion sort function to sort individual buckets static void InsertionSort(Listbøtte) { for (int i = 1; i< bucket.Count; ++i) { float key = bucket[i]; int j = i - 1; while (j>= 0 && bøtte[j]> nøkkel) { bøtte[j + 1] = bøtte[j]; j--; } bøtte[j + 1] = nøkkel; } } // Funksjon for å sortere arr[] av størrelse n ved å bruke bøttesortering static void BucketSort(float[] arr) { int n = arr.Length; // 1) Opprett n tomme bøtteliste[] bøtter = ny liste[n]; for (int i = 0; i< n; i++) { buckets[i] = new List(); } // 2) Plasser matriseelementer i forskjellige bøtter for (int i = 0; i< n; i++) { int bi = (int)(n * arr[i]); buckets[bi].Add(arr[i]); } // 3) Sort individual buckets using insertion sort for (int i = 0; i < n; i++) { InsertionSort(buckets[i]); } // 4) Concatenate all buckets into arr[] int index = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < buckets[i].Count; j++) { arr[index++] = buckets[i][j]; } } } // Driver program to test above function static void Main(string[] args) { float[] arr = { 0.897f, 0.565f, 0.656f, 0.1234f, 0.665f, 0.3434f }; BucketSort(arr); Console.WriteLine('Sorted array is:'); foreach (float num in arr) { Console.Write(num + ' '); } } }> JavaScript function insertionSort(bucket) { for (let i = 1; i < bucket.length; ++i) { let key = bucket[i]; let j = i - 1; while (j>= 0 && bøtte[j]> nøkkel) { bøtte[j + 1] = bøtte[j]; j--; } bøtte[j + 1] = nøkkel; } } funksjon bucketSort(arr) { la n = arr.length; la buckets = Array.from({lengde: n}, () => []); // Sett matriseelementer i forskjellige bøtter for (la i = 0; i< n; i++) { let bi = Math.floor(n * arr[i]); buckets[bi].push(arr[i]); } // Sort individual buckets using insertion sort for (let i = 0; i < n; i++) { insertionSort(buckets[i]); } // Concatenate all buckets into arr[] let index = 0; for (let i = 0; i < n; i++) { for (let j = 0; j < buckets[i].length; j++) { arr[index++] = buckets[i][j]; } } } let arr = [0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434]; bucketSort(arr); console.log('Sorted array is:'); console.log(arr.join(' '));> Produksjon
Sorted array is 0.1234 0.3434 0.565 0.656 0.665 0.897>
Kompleksitetsanalyse av bøttesorteringsalgoritme:
Tidskompleksitet: På2),
mylivecricket.
- Hvis vi antar at innsetting i en bøtte tar O(1) tid, tar trinn 1 og 2 i algoritmen ovenfor tydelig O(n) tid.
- O(1) er lett mulig hvis vi bruker en koblet liste for å representere en bøtte.
- Trinn 4 tar også O(n) tid da det vil være n elementer i alle bøttene.
- Hovedtrinnet å analysere er trinn 3. Dette trinnet tar også O(n) tid i gjennomsnitt hvis alle tall er jevnt fordelt.
Hjelpeplass: O(n+k)