sortering algoritme sammenligning
sortering algoritmer er en vigtig del af forvaltningen af data. AtCprogramming.com, vi tilbyder tutorials for at forstå de vigtigste ogalmindelige teknikker. Hver algoritme har særlige styrker ogsvagheder og i mange tilfælde er den bedste ting at gøre bare at bruge den indbyggede insorteringsfunktion. For tidspunkter, hvor dette ikke er en mulighed, eller du bare har brug foren hurtig og beskidt sorteringsalgoritme, der er en række valg.
De fleste sorteringsalgoritmer fungerer ved at sammenligne de data, der sorteres. I nogle tilfælde kan det være ønskeligt at sortere en stor del af data (for eksempel astruct indeholdende et navn og en adresse) baseret på kun en del af disse data.Det stykke data, der faktisk bruges til at bestemme den sorterede rækkefølge, kaldes nøglen.sorteringsalgoritmer bedømmes normalt ud fra deres effektivitet. I dette tilfælde refererer effektivitet til den algoritmiske effektivitet, da inputstørrelsen vokserstor og er generelt baseret på antallet af elementer, der skal sorteres. De fleste af dealgoritmer, der er i brug, har en algoritmisk effektivitet på enten O(n^2) orO(n*log(n)). Et par specielle tilfælde algoritmer(et eksempel er nævnt i programmering perler) kan sortere bestemte datasæt hurtigere end O(n*log (n)). Disse algoritmer er ikke baseret på at sammenligne de emner, der sorteres, og stole påtricks. Det har vist sig, at ingen nøgle-sammenligning algoritme kan udføre bedreend O(n*log(n)).
mange algoritmer, der har samme effektivitet, har ikke samme hastighed pådet samme input. Først, algoritmer skal bedømmes ud fra deres gennemsnitlige sag,bedste sag, og værst tænkelige effektivitet. Nogle algoritmer, såsom hurtig sortering,fungerer usædvanligt godt for nogle input, men forfærdeligt for andre. Andrealgoritmer, såsom fletningssortering, påvirkes ikke af rækkefølgen af inputdata.Selv en modificeret version af bubble sort kan afslutte I O (n) for de mestgunstige input.
En anden faktor er det “konstante udtryk”. Som big – O notation abstracts væk mangeaf detaljerne i en proces, er det ret nyttigt at se på bigpicture. Men en ting, der bliver droppet ud, er konstanten foran udtrykket: for eksempel er O(c*n) bare O(n). I den virkelige verden, thekonstant, c, vil variere på tværs af forskellige algoritmer. En velimplementerethurtsort skal have en meget mindre konstant multiplikator end heap sort.
et andet kriterium for at bedømme algoritmer er deres pladsbehov – dode kræver ridseplads eller kan arrayet sorteres på plads (udenyderligere hukommelse ud over nogle få variabler)? Nogle algoritmer kræver aldrigekstra plads, mens nogle lettest forstås, når de implementeres medekstra plads (heap sort, for eksempel, kan gøres på plads, men konceptueltdet er meget lettere at tænke på en separat bunke). Pladsbehov kan endda afhænge af den anvendte datastruktur (Flet sortering på arrays versus Flet sortering onlinked lister, for eksempel).
et tredje kriterium er stabilitet – bevarer sorteringen rækkefølgen af nøgler med lige værdier? De fleste enkle sorter gør netop dette, men nogle slags, sådan sombillig slags, gør det ikke.
følgende diagram sammenligner sorteringsalgoritmer på de forskellige kriterierovertegnet; algoritmerne med højere konstante udtryk vises først, selvom dette klart er et implementeringsafhængigt koncept og bør kun tages som en grov guide, når man vælger mellem slags af samme big-O-effektivitet.
| Time | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| Sort | Average | Best | Worst | Space | Stability | Remarks | ||||
| Bubble sort | O(n^2) | O(n^2) | O(n^2) | Constant | Stable | Always use a modified bubble sort | ||||
| Modified Bubble sort | O(n^2) | O(n) | O(n^2) | Constant | Stable | Stops after reaching a sorted array | ||||
| Selection Sort | O(n^2) | O(n^2) | O(n^2) | konstant | stabil | selv en perfekt sorteret indgang kræver scanning af hele arrayet | ||||
| Indsætningssortering | O(n^2) | O(n) | O(n^2) | O (n) | O(n ^ 2) | konstant | stabil | i bedste fald(allerede sorteret) kræver hver indsats konstant tid | ||
| Heap sort | o(n*log(n)) | o(n*log(n)) | o (n*log (n)) | o (n * log (n)) | o (n * log (n)) | o (n * log (n)) | o (n * log (n)) | konstant | instable | ved at bruge input array som opbevaring til bunken er det muligt at opnå konstant plads |
| Flet sortering | o(n*log(n)) | O(n*log(n)) | o(n*log(n)) | afhænger | stabil | på arrays kræver fletningssortering o(n) plads; på sammenkædede lister kræver fletningssortering konstant plads | ||||
| O(n*log(n)) | O(n*log(n)) | O(n^2) | konstant | stabil | tilfældigt at vælge en Pivotværdi (eller blande arrayet før sortering) kan hjælpe med at undgå værste tilfælde, såsom et perfekt sorteret array. | |||||