1 / 23

Datastrukturer och algoritmer

Datastrukturer och algoritmer. Föreläsning 13 20 min för kort!!. Innehåll. Sortering Sortering vs sorterad datatyp Stabilitet Grundprinciper för sortering Genomgång av några sorteringsalgoritmer Hur fort går det att sortera en lista med n tal? Kapitel 15.1-15.4. Sortering varför?.

lluvia
Télécharger la présentation

Datastrukturer och algoritmer

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Datastrukturer och algoritmer Föreläsning 13 20 min för kort!!

  2. Innehåll • Sortering • Sortering vs sorterad datatyp • Stabilitet • Grundprinciper för sortering • Genomgång av några sorteringsalgoritmer • Hur fort går det att sortera en lista med n tal? • Kapitel 15.1-15.4

  3. Sortering varför? • Snabba upp andra algoritmer • Sökning • Hantera stora datamängder

  4. Sortering vs Sorterad datatyp • Sortering • förändrar ordningen mellan objekten i en struktur efter en sorteringsordning (fallande, ökande) • Sorterad datatyp • de strukturförändrande operationerna i gränsytan (insert, delete) upprätthåller en sorteringsordning mellan de lagrade objekten

  5. Saker att beakta • Absolut komplexitet • Totala komplexiteten i alla implementationssteg • Tabell->Lista->Dubbellänkad Lista • Passar en viss typ av sortering för en viss typ av implementation? • Ska man sortera och sedan söka eller inte sortera och göra en linjär sökning?

  6. Stabilitet • Den inbördes relationen mellan två objekt med samma nyckel bibehålls vid sortering [(0,L),(2,C),(5,G),(8,A),(10,G) ] => [(8,A),(2,C),(5,G) ,(10,G),(0,L)] • Alla sorteringsalgoritmer går inte att göra stabila!! • Mer om detta senare…

  7. Olika grundprinciper • Insättnings – O(n2) • välj ut ett godtyckligt objekt och sätt in det på rätt plats • Urvals – O(n2) • välj ut det objekt som är på tur och sätt in det sist/först • Utbytes – O(n*log(n)) • byt plats på objekt som ligger fel inbördes • Samsortering – O(n*log(n)) • bygger på sammanslagning av redan sorterade strukturer • Nyckelsortering – O(m+n)… • kräver mer information/kunskap om objektmängden

  8. Mer principer… • Naiva sorteringar - O(n2) • Insticks, urvals, och vissa utbytes • ”Smarta” sorteringar - O(nlog(n)) • Utbytes och samsorteringar • Ännu smartare sorteringar - O(n+m)… • Nyckelsorteringar…(nästa föreläsning)

  9. Sammanfattande tabellbaserad på tabellen på sidan http://en.wikipedia.org/wiki/Sorting_algorithm

  10. Animeringar att titta på • Animering som visar hur sorteringen beter sig för listor som är • slumpmässiga, • nästan sorterade • omvänt sorterade • samt listor med många dubletter (få unika tal) http://vision.bc.edu/~dmartin/teaching/sorting/anim-html/all.html • Animering som visar ett mindre exempel i detalj http://math.hws.edu/TMCM/java/xSortLab/

  11. Insertion sort - insättningssortering • Välj ett godt. objekt och sätt in det på rätt plats • O(n2) • Enkel att implementera • Effektivitet • bäst för mindre datamängder och datamängder som är nästan sorterade • i praktiken mer effektiv än selection sort och bubble sort • Stabil • Kan göras in-place • Konstant andel extra minne (motsv elementens storlek) • Kan sortera en lista allt eftersom den byggs upp.

  12. Selection sort - urvalssortering • Välj det objekt som är på tur och sätt in det sist/först • O(n2) • Enkel att implementera • Effektivitet • bäst på mindre datamängder • beter sig lika oavsett datamängdens utseende • i praktiken mer effektiv än bubble sort • Kräver mindre ”swaps” än insertion sort • Bra om ”dyrare” att skriva till minnet än att läsa från det. • Inte stabil • kan göras stabil men då tappar man fördelar jämfört med insertion sort (mer swaps). • Kan göras in-place • Konstant andel extra minne (motsv elementens storlek)

  13. Bubble sort - utbytessortering • byta plats på objekt som ligger fel inbördes • O(n2) • Enkel (enklast?) att implementera • Effektivitet • bäst på mindre datamängder och nästan sorterade mängder • i praktiken sämre än både insertion sort och selection sort • Kräver mer ”swaps” än insertion sort • Stabil • Kan göras in-place • Konstant andel extra minne (motsv elementens storlek)

  14. Divide and Conquer • Rekursiv algoritmprincip • Grundidén är att dela upp problemet i mindre och mindre problem • Lös problemen för basfallet • Slå ihop dem till en totallösning • Mergesort och Quicksort är av denna algoritmtyp • O(n*log(n))

  15. Mergesort – samsortering • Bygger på sammanslagning av redan sorterade strukturer • O(n log n) • Effektivitet • snabbare och gör mindre jämförelser än quicksort • gör fler rekursiva anrop än quicksort men kan skrivas iterativt • Stabil • Kan göras in-place • Speciellt om listan är konstruerad som länkad lista • Oftast inte in-place, minnesutrymmet kan påverka ett val!

  16. Mergesort – samsortering • Algoritm för att sortera sekvensen S • Divide: Om S har 2 eller flera element dela S i två lika stora delsekvenser S1 och S2 • Recurse: Sortera sekvenserna S1 och S2 rekursivt • Conquer: Sätt tillbaka elementen i S genom att slå samman S1 och S2 till en sorterad sekvens

  17. Ihopslagning av två sekvenser Agorithm merge(S1,S2,S) while S1 is not empty and S2 is not empty do if S1.first().element() ≤ S2.first().element() then S.insertLast(S1.remove(S1.first())) else S.insertLast(S2.remove(S2.first())) while S1 is not empty do S.insertLast(S1.remove(S1.first())) while S2 is not empty do S.insertLast(S2.remove(S2.first()))

  18. Exempel på sammanslagning 3 5 7 15 19 S1 0 2 3 5 6 7 7 9 15 19 S 0 2 6 7 9 S2

  19. Analys av exekveringstiden • Höjden på sorteringsträdet kopplat till sorteringen av en sekvens med n element blir log2(n) • Antag att insättning och borttagning är av O(1) • Tiden i varje nod i trädet exkluderat tiden för det rekursiva jobbet nedanför är O(n/2i) där i är djupet på noden ligger på, ty storleken på sekvensen är n/2i • Det är exakt 2i noder på djupet i => totala tiden på djupet i i trädet är O(2in/2i) vilket är O(n) och höjden på trädet är log2(n) • Så den totala tidskomplexiteten är O(nlog2(n))

  20. Quicksort • Algoritm • Välj ut ett pivotelement • Dela upp listan i tre delar Less, Equal, Greater • Sortera Less och Greater rekursivt • Slå ihop Less+Equal+Greater

  21. Inplace variant av quicksort • Algoritm • Traversera parallellt från båda hållen i S, gå bakåt från början av S tills man hittar ett element som är >= PE, traversera från slutet mot början till man hittar ett element som är < PE • Skifta plats på dessa två element • Upprepa till traverseringarna mötes • Skifta in PE på rätt plats • Rekursivt anrop med Less och Greater

  22. Quicksort - val av pivoelement • O(nlog(n)) i bästa fallet • Valet av pivoelement kritiskt • Vill ha ett pivoelement som ligger i mitten • Vid sned fördelning får man insticks/urvals sortering med O(n2) • Alternativ (eftersträvar en enkel tilldelning) • Välj första/sista, slumpmässigt • Medel/median mellan några stycken • Största av de två första som skiljer sig åt

  23. Hur snabbt kan man sortera? • Jämförelsebaserad sortering • Ω(nlog(n)) undre gräns • Nyckelsortering snabbare… • Nästa föreläsning

More Related