Invoering
Sorteren is een essentiële handeling in de informatica waarbij elementen in een specifieke volgorde worden gerangschikt, zoals numerieke of alfabetische volgorde. Er zijn verschillende sorteeralgoritmen ontwikkeld, elk met tijd- en efficiëntie-indicatoren. Lineaire tijdsortering is een subset van sorteeralgoritmen met een aanzienlijk voordeel: ze kunnen een gegeven reeks elementen in lineaire tijd sorteren, de looptijd neemt lineair toe met de invoergrootte.
Het bekendste algoritme voor lineaire tijdsortering is de aflopende sortering. Computationeel sorteren is bijzonder efficiënt wanneer het bereik van invoerelementen bekend en relatief klein is. Dit elimineert de noodzaak om elementen te vergelijken, de belangrijkste tijdrovende bewerking bij veel andere sorteeralgoritmen. Met behulp van kennis van het invoerdomein bereikt computationeel sorteren een lineaire tijdscomplexiteit. Een numerieke sortering scant eerst de invoerarray om het aantal van elk element te bepalen. Vervolgens gebruikt het deze getallen om de juiste posities van de elementen in de geordende resultatentabel te berekenen. Het algoritme bestaat uit de volgende stappen:
- Om het bereik te bepalen, identificeert u de minimum- en maximumwaarden van de invoerarray.
- Maak een werkblad dat is geïnitialiseerd met de bereikgrootte en nullen.
- Herhaal de invoerarray en verhoog elk gevonden element.
- Pas het werkblad aan door het cumulatieve totaal te berekenen om de juiste posities voor elk element te verkrijgen.
- Maak een uitvoerarray van dezelfde grootte als de invoerarray.
- Verplaats de invoerarray opnieuw en plaats elk element op de juiste positie in de uitvoerarray op basis van het werkblad.
- De resultatentabel bevat nu gesorteerde elementen.
Het belangrijkste voordeel van aflopend sorteren is dat het een lineaire tijdscomplexiteit van O(n) bereikt, waardoor het zeer efficiënt is voor grote invoergroottes. De toepasbaarheid ervan is echter beperkt tot scenario's waarin de keuze van de inputelementen vooraf bekend is en relatief klein is.
Het is belangrijk op te merken dat andere sorteeralgoritmen, zoals quicksort of merge, doorgaans een tijdscomplexiteit hebben van O(n log n), wat voor veel praktische toepassingen als efficiënt wordt beschouwd. Algoritmen voor lineaire tijdsortering, zoals numerieke sortering, bieden een alternatief wanneer bepaalde beperkingen of eigenschappen van de invoer het gebruik van lineaire tijdscomplexiteit mogelijk maken.
Geschiedenis
Algoritmen voor lineaire tijdsortering hebben een rijke geschiedenis in de informatica. De ontwikkeling van de lineaire tijdsorde gaat terug tot het midden van de 20e eeuw, en de bijdragen van wetenschappers en wiskundigen waren aanzienlijk. Een van de eerste algoritmen voor lineaire tijdsortering is de bucket-sort, voorgesteld door Harold H. Seward in 1954. Een bucket-sort verdeelt de invoerelementen in een eindig aantal buckets en sorteert vervolgens elke bucket afzonderlijk. Dit algoritme heeft een lineaire tijdscomplexiteit als de verdeling van invoerelementen relatief uniform is.
In 1959 introduceerde Kenneth E. Iverson een radix-algoritme dat lineaire tijdscomplexiteit bereikt. Radix sorteert elementen op basis van hun cijfers of tekens, van minst significant naar meest significant. Het maakt gebruik van robuuste sorteeralgoritmen, zoals numeriek of bucket-sorteren, om de elementen op elke cijferlocatie te sorteren. Radix-sortering werd populair in het tijdperk van ponskaarten en vroege computersystemen. Het bekendste algoritme voor lineaire tijdsortering is echter een opsomming, geïntroduceerd door Harold H. Seward en Peter Elias in 1954 en later onafhankelijk herontdekt door Harold H. 'Bobby' Johnson in 1961. Numerieke sortering heeft veel aandacht gekregen.
Dit is vooral effectief als het bereik aan invoerelementen bekend en relatief klein is. De geschiedenis van lineaire tijdsortering ging verder met de ontwikkeling van andere gespecialiseerde algoritmen. In 1987 stelde Hanan Samet bijvoorbeeld binaire distributieboomsortering voor, een lineair tijdsorteringsalgoritme voor multidimensionale gegevens. Door de jaren heen zijn onderzoekers lineaire planningsalgoritmen blijven bestuderen en verbeteren, waarbij ze zich concentreerden op specifieke scenario's en beperkingen. Hoewel algoritmen zoals quicksort en merge op grotere schaal worden gebruikt vanwege hun efficiëntie in meer scenario's, bieden lineaire tijdsorteringsalgoritmen waardevolle alternatieven wanneer bepaalde omstandigheden het mogelijk maken dat de lineaire tijdcomplexiteit wordt uitgebuit. Over het algemeen wordt de geschiedenis van lineaire tijdsortering gekenmerkt door het zoeken naar efficiënte algoritmen die grote datasets in lineaire tijd kunnen sorteren, waardoor de beperkingen van op vergelijkingen gebaseerde sorteeralgoritmen worden overwonnen. De bijdragen van verschillende onderzoekers maakten de weg vrij voor het ontwikkelen en begrijpen van deze gespecialiseerde sorteertechnieken.
Soorten lineaire tijdsortering
Er zijn verschillende lineaire tijdsorteringsalgoritmen. De twee belangrijkste typen zijn op tellingen gebaseerde algoritmen en op radix gebaseerde algoritmen. Hier zijn de meest voorkomende algoritmen voor lineaire tijdsortering, geclassificeerd op basis van de volgende typen:
Op tellen gebaseerde algoritmen
Radix-gebaseerde algoritmen
Voordelen van lineaire tijdsortering
Algoritmen voor lineaire tijdsortering, zoals numerieke sortering, bieden in specifieke scenario's verschillende voordelen.
Nadelen van lineaire tijdsortering
Hoewel lineaire planningsalgoritmen hun voordelen hebben, hebben ze ook bepaalde beperkingen en nadelen:
Bij het kiezen van een sorteeralgoritme is het essentieel om zorgvuldig rekening te houden met de specifieke kenmerken van de invoergegevens en de vereisten van het sorteerprobleem. Hoewel lineaire planningsalgoritmen voordelen bieden in specifieke scenario's, zijn ze slechts soms de meest geschikte of efficiënte keuze.
Toepassingen van lineaire tijdsorteringsalgoritmen
Lineaire tijdsorteringsalgoritmen zijn efficiënt en hebben vele toepassingen op verschillende gebieden. Hier zijn enkele typische toepassingen van lineaire tijdvolgorde:
Implementatie van lineaire tijdsortering in C++
Hier is een voorbeeld van een programma dat Counting Sort implementeert, een lineair tijdsorteringsalgoritme:
#include #include using namespace std; void countingSort(vector& arr) { // Find the maximum element in the array int max_val = *max_element(arr.begin(), arr.end()); // Create a count array to store the count of each element vector count(max_val + 1, 0); // Count the occurrences of each element for (int num : arr) { count[num]++; } // Compute the prefix sum for (int i = 1; i <count.size(); i++) { count[i] +="count[i" - 1]; } create a sorted output array vector output(arr.size()); place the elements in order for (int i="arr.size()" 1;>= 0; i--) { output[count[arr[i]] - 1] = arr[i]; count[arr[i]]--; } // Copy the sorted elements back to the original array for (int i = 0; i <arr.size(); i++) { arr[i]="output[i];" } int main() vector arr="{4," 2, 8, 3, 1}; sort the array using counting countingsort(arr); print sorted cout << 'sorted array: '; for (int num : arr) ' endl; return 0; < pre> <p> <strong>Sample Output</strong> </p> <pre> Sorted array: 1 2 2 3 3 4 8 </pre> <p>This indicates that the input array has been sorted in ascending order using the Counting Sort algorithm, resulting in the sorted array [1, 2, 2, 3, 3, 4, 8].</p> <p>In this C++ program, the counting sort function takes a reference to the vector arr and runs the counting sort routine. It finds the table's maximum value to determine the worksheet's size. It then counts each element's occurrence and calculates the worksheet's prefix sum. Then, it creates a result vector and puts the elements in order according to the worksheet. Finally, it copies the sorted elements back into the original array. In the primary function, the example array {4, 2, 2, 8, 3, 3, 1} is sorted by the enumeration sort algorithm and printed as a sorted matrix. Note that the program uses libraries to work with vectors and find the maximum element of an array using the max_element function.</p> <hr></arr.size();></count.size();>
Dit geeft aan dat de invoerarray in oplopende volgorde is gesorteerd met behulp van het Counting Sort-algoritme, wat resulteert in de gesorteerde array [1, 2, 2, 3, 3, 4, 8].
In dit C++-programma neemt de tellende sorteerfunctie een verwijzing naar de vector arr en voert de tellende sorteerroutine uit. Het vindt de maximale waarde van de tabel om de grootte van het werkblad te bepalen. Vervolgens telt het het voorkomen van elk element en berekent het de prefixsom van het werkblad. Vervolgens wordt er een resultaatvector gemaakt en worden de elementen gerangschikt volgens het werkblad. Ten slotte kopieert het de gesorteerde elementen terug naar de originele array. In de primaire functie wordt de voorbeeldarray {4, 2, 2, 8, 3, 3, 1} gesorteerd door het opsommingssorteeralgoritme en afgedrukt als een gesorteerde matrix. Merk op dat het programma bibliotheken gebruikt om met vectoren te werken en het maximale element van een array te vinden met behulp van de functie max_element.