datastrukturer och algoritmer

Datastrukturer och algoritmer

Föreläsning 1320 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?

Snabba upp andra algoritmer Sökning Hantera stora

datamängder

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

Saker att beakta

Absolut komplexitet Totala komplexiteten i alla implementationssteg

o 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?

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…

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

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)

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

Namn Bäst Medel Sämst Minne Stabil Typ

Insertion sort O(n) O(n + d) O(n2) O(1) X Insättning

Selection sort O(n2) O(n2) O(n2) O(1) Urval

Bubble sort O(n) — O(n2) O(1) X Utbyte

Merge sort O(n log n) O(n log n) O(n log n) O(n) X Samsortering

In-place merge sort

O(n log n) O(n log n) O(n log n) O(1) X Samsortering

Quicksort O(n log n) O(n log n) O(n2) O(log n) Utbyte

Heapsort O(n log n) O(n log n) O(n log n) O(1) Urval

Bucket sort (Pigeon hole sort)

O(n+m) O(n+m) O(n+m) O(k) X Nyckel

LSD Radix sort O(n·k/s) O(n·k/s) O(n·k/s) O(n) X Nyckel

MSD Radix sort O(n·k/s) O(n·k/s) O(n·(k/s)·2s)

O((k/s)·2s) Nyckel

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/

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.

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

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

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))

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!

Mergesort – samsortering

Algoritm för att sortera sekvensen SDivide: Om S har 2 eller flera element dela S i

två lika stora delsekvenser S1 och S2Recurse: Sortera sekvenserna S1 och S2

rekursivt Conquer: Sätt tillbaka elementen i S genom att

slå samman S1 och S2 till en sorterad sekvens

Ihopslagning av två sekvenserAgorithm merge(S1,S2,S)while S1 is not empty and S2 is not empty do

if S1.first().element() ≤ S2.first().element() thenS.insertLast(S1.remove(S1.first()))

elseS.insertLast(S2.remove(S2.first()))

while S1 is not empty doS.insertLast(S1.remove(S1.first()))

while S2 is not empty doS.insertLast(S2.remove(S2.first()))

3 195 7 15S1

0 92 6 7

3 195 7 150 92 6 7

Exempel på sammanslagning

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))

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

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

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)

o Välj första/sista, slumpmässigto Medel/median mellan några styckeno Största av de två första som skiljer sig åt

Hur snabbt kan man sortera?

Jämförelsebaserad sortering Ω(nlog(n)) undre gräns

Nyckelsortering snabbare… Nästa föreläsning

datastrukturer och algoritmer

Documents

inf2220 - algoritmer og datastrukturer - uio

algoritmer og datastrukturer 2 graf repræsentationer, bfs...

inf2220 - algoritmer og datastrukturer

algoritmer og datastrukturer kapittel 5 − delkapittel 5

algoritmer og datastrukturer 2 maksimale strømninger [clrs,...

tdt4120 algoritmer og datastrukturer introduksjon til...

datastrukturer och algoritmer - ida > home · pdf file1...

algoritmer og datastrukturer 1 amortiseret analyse [clrs,...

datastrukturer och algoritmer

algoritmer og datastrukturer 2

dm507 | algoritmer og...

algoritmer og datastrukturer 1

algoritmer og datastrukturer 1 · 2013. 2. 4. ·...

inf 295 algoritmer og datastrukturer forelesning 10 ...

algoritmer og datastrukturer 2 grådige algoritmer [clrs...

datastrukturer och algoritmer - umu.sealgoritmer, 2:a uppl.,...

algoritmer og datastrukturer 1 - aarhus...

skriftlig eksamen algoritmer og datastrukturer...

algoritmer og datastrukturer 1 - aarhus...

algoritmer och datastrukturer