mm5: sorting algorithms - november 1,...

1

Algorithms and Architectures IRasmus Løvenstein Olsen (RLO)

Mm5: Sorting algorithms- November 1, 2010

2

Algorithms and Architectures II

1. Introduction to analysis and design of algorithms (RLO - 11/10)2. Recursive algorithms and recurrences (RLO - 12/10)3. Implementation of recursive algorithms (Self study - 25/10)4. Greedy algorithms, backtracking and recurrences (Self study - 26/10)5. Sorting algorithms (RLO - 1/11)6. Implementation of sorting algorithms (Self study - 2/11)7. Counting, probabilities and randomized algorithms (RLO - 8/11)8. Hash tables and Hashing (RLO - 10/11)9. Binary search trees, red-black trees and string matching (RLO - 15/11)10. Course round-up (RLO - 16/11)

2

3

Sortering af data

• Sortering af data sker mange steder• Data baser• Regneark• Videnskabelig analyse af måle data• …

• Flere eksempler på sorteringsalgoritmer• Heap sort

• Organisering af data i såkaldte heaps

• Quick sort• Re-arrangering af data efter valgt pivot punkt

• Counting sort• Baserer sig på antal af specifikke elementer og udnytter specifik viden om data

• Bucket sort• Re-organisering af data i ”buckets”

4

Dagsorden

• To ”almindelige” sorteringsalgoritmer• Heap sort• Quick sort

• Lineær versus ulineær sortering

• Eksempler på sorteringsalgoritmer i lineær tid• Counting sort• Radix sort• Bucket sort

• Opsummering og konklusion• Opgaver

5

Hvad er en heap?

• En (binær) heap er en data struktur der kan karakteriseres som et array med et næsten komplet binært træ

• Et array A der representerer sådan en strukturindeholder• Længde : length[A]• Heap størrelse : heap-size[A]• heap-size[A] ≤ length[A]

• Grafisk representation

A

B C

D E

A B C D E

6

Heap specifikke operationer

• Parent(i)• Return(i/2)

• Left(i)• Return 2i

• Right(i)• Return 2i+1

1

2 3

4 5 6 7

8 9 10

7

Max-heap og min-heap• Max-heap egenskab

• A[parent(i)] ≥ A[i]Det største element er root elementet, og alle under elementer har værdier mindre end elemente selv

• Min-heap egenskab• A[parent(i)] ≤ A[i]

Det mindste element er root elementet, og alle under elementer har værdier større end elementet selv

• Egenskaberne bliver udnyttet i forskellige sammenhæng, f.eks. Prioritetskøer og sorteringsalgoritmer

• Vi ser på heapsort der udnytter disse egenskaber og kigger på flg. Procedurer• Max-heapify: Sikrer vores heap egenskaber bibeholdes, T(n) = O(log(n))• Build-max-heapify: Producerer en max-heap fra et usorteret input, T(n) = O(n)• Heapsort algoritme: Sorterer arrayet, T(n) = O(nLog(n))

8

Vedligeholdelse af heap egenskab – MAX-HEAPIFY

• Input til algoritme: et array A og et indeks i til arrayet

• Vi antager de binære træer, med rod i Left[i] og Right[i] er max-heaps

• A[i] er derimod muligvis mindre end dens undergrene

MAX-HEAPIFY (A, i)

1 L = Left(i) 6 If R ≤ heap-size[A] and A[r]>A[largest]

2 R = Right(i) 7 then largest = R

3 If L≤heap-size(A) and A[L] > A[i] 8 If largest ≠ i

4 then largets = L 9 then exchange A[i] with A[largest]

5 else largest = i 10 MAX-HEAPIFY(A, largest)

9

Eksempel med Max-heapify

• Heap-size[A] = 10

• Initial værdi af A• A[2] = 4 bryder max-heap egenskabet

idet den ikke er større end dens to undergrene

• Vi skal have flyttet den således vi genskaber/ opnår max-heap egenskab

16

4 10

14 7 9 3

2 8 1

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

16 4

10

14 7 9 3 2 8 1

1 10

10

Eksempel med Max-heapify #2

Ved udskiftning med A[4] opnår vi:• Genoprettelse/opnåelse af max-

heap egenskab for node 2• Vi har nu A[4] = 4 > A[9]• Ødelæggelse af max-heap

egenskab for node 4• Vi skal have flyttet mere rundt på

tingene

16

14 10

4 7 9 3

2 8 1

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

16

14

10 4 7 9 3 2 8 1

1 10

11

Eksempel med Max-heapify #3

Ved rekursivt kald til max-heapifyopnår vi:

• A[9] = 4, A[4] = 8• Dermed har vi opnået et max-heap

egenskab for det binære træ

16

14 10

8 7 9 3

2 4 1

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

16

14

10 8 7 9 3 2 4 1

1 10

12

Max-heapify algoritme kompleksitet

• Eksekveringstiden for max-heapify algoritmen er flg.• Θ(1) for at genoprette forholdet mellem A[i], A[Left(i)] og A[Right(i)]

plus tiden for at udføre max-heapify på en af de underliggende knudepunkter• De enkelte undergrene har hver maksimalt 2n/3 elementer

værste tilfælde når den sidste række er fyldt helt op (hvorfor det er 2n/3 er op til jer selv at finde ud af☺)

• Dermed er rekursiviteten givet ved

• Den har vi set før... Og giver T(n) = O(log2(n))

)1()3/2()( Θ+≤ nTnT

13

Konstruering af en heap

• Vi kan nu benytte os af Max-Heapify til at konvetere et array A[1..n] til en max-heap

Build-Max-Heap (A)

1 Heap-size[A] = length[A]

2 For i = length[A]/2 downto 1

3 do Max-Heapify (A,i)

14

Hvordan Build-Max-heap virker - grafisk

4

1 3

2 16 9 10

14 8 7

1

2 3

4 5 6 7

8 9 10

4 1 3 216 9

10

14 8 7

4

1 3

2 16 9 10

14 8 7

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

14

15

Hvordan Build-Max-heap virker – grafisk #2

4

1 3

14 16 9 10

2 8 7

1

2 3

4 5 6 7

8 9 104

1 10

14 16 9 3

2 8 7

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

10

16

7

16

Hvordan Build-Max-heap virker – grafisk #3

4

16 10

14 7 9 3

2 8 1

1

2 3

4 5 6 7

8 9 1016

14 10

8 7 9 3

2 4 1

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

14

8

16

17

Bevis for korrekthed af Build-Max-Heap

• Loop invariant defineres som• Ved begyndelsen af hver iteration af For loopet i linie 2-3,

er knudepunkterne i+1, i+2, ... N roden af en max-heap

• Initialisering af algoritmen:• Pga. konstruktionen af en heap bliver elementerne n/2 + 1, n/2 +2, ... , n automatisk

klassificeret som endepunkter i træet. Det er det samme som de er rod for et 1-element stort max-heap. Derfor holder loop invarianten under initialisering af algoritmen.

1

2 3

4 5 6 7

8 9 101 2 3 4 5 6 7 8 9

10

Ekse

mpe

l

18

Bevis for korrekthed af Build-Max-Heap #2

• Vedligeholdelse af algoritmen• Bemærk at

• Undergrenen af den i’te knude, er altid nummereret højere end i• Undergrenen af den i’te knude er altid en rod i en max-heap!

• Ved start af loop (markeret med blå) er max-heap egenskab opretholdt for undergrene

• Ved udløb, er det samme gældende nu også fra i4

1 10

14

16

9 3

2 8 7

1

2 3

4 5 6 7

8 9 10

(1) (2)

4

1 3

2 16

9 10

14

8 7

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

19

Bevis for korrekthed af Build-Max-Heap #3

• Terminering: Når i = 0 skal samtlige knudepunkter iflg. Loop invarianten være rod for et max-heap

16

14 10

8 7 9 3

2 4 1

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

20

Udførselstid for Build-Max-heap

• Udførslen af max-heapify er O(log2(n))

• Max-heapify bliver kaldt O(n) gange, og dermed får vi en øvre grænse for vores kompleksitet på O(nLog2(n))

• Men, vi kan gøre det bedre!

• En n-element heap har højden h = Log2(n) og allerhøst n/2h+1 knuder (hvorfor, er en opgave for den nysgerrige elev ☺)

• Tiden for max-heapify kan også skrives som O(h), og så kan vi finde den samlede tidsmæssige pris for udførslen af algoritmen

• Dermed har vi en kompleksitet på O(n) (men den falder selvfølgelig ogsåunder O(nLog2(n)).

21

Heap sort algoritmen! Endelig…

• Pudsigt nok bygger heap sort på• Build-Max-Heap• Max-Heapify

• Algoritmen baserer sig påudskiftning mellem øversteog nederste element og derefter re-etablering afheap egenskabet

• Heap sort er en meget anvendt algoritme, bl.a. til prioritets køer som vi ser nærmeret på lidt senere

Heap-sort(A)

1 Build-max-heap(A)

2 For i = length(A) downto 2

3 do exchange A[1] = A[i]

4 heap-size[A] = heap-size[A] – 1

5 Max-Heapify (A, 1)

22

Heap sort – grafisk gennemgang

16

14 10

8 7 9 3

2 4 1

1

2 3

4 5 6 7

8 9 10 14

8 10

4 7 9 3

2 1 16

1

2 3

4 5 6 7

8 9 10

Udgangspunkt efter Build-Max-Heapify

16

14

10 8 7 9 3 2 4 1

Ekse

mpe

l

23


10

8 9

4 7 1 3

2 14 16

1

2 3

4 5 6 7

8 9 10 9

8 3

4 7 1 2

10 14 16

1

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

24


18

7 3

4 2 1 9

10 14 16

2 3

4 5 6 7

8 9 10 7

4 3

1 2 8 9

10 14 16

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

25

Heap sort – grafisk gennemgang1

4

2 3

1 7 8 9

10 14 16

2 3

4 5 6 7

8 9 10

13

2 1

4 7 8 9

10 14 16

2 3

4 5 6 7

8 9 10

Ekse

mpe

l

26

Heap sort – grafisk gennemgang1

2

1 3

4 7 8 9

10 14 16

2 3

4 5 6 7

8 9 10

11

2 3

4 7 8 9

10 14 16

2 3

4 5 6 7

8 9 101 2 3 4 7 8 9

10

14

16

Ekse

mpe

l

27

Heap sort - køretid• Heap sort proceduren tager O(nLog(n))

• Build-Max-Heap(n) = O(n)• Max-Heapify(n) = O(Log(n)) (kaldes n-1 gange)

• Sammenlign med Quicksort der tager O(n2)• Der dog i gennemsnit, O(nLog(n)), har en bedre tid end heap sort

• Og med merge-sort Θ(nLog(n))• Der dog kræver Ω(n) lager plads mod O(1) lager plads for heap sort

• En hybrid af quicksort og heap sort blev udviklet i 1997• Algoritmen starter med quick sort og ved en hvis størrelse af

rekursivitetsdybden skifter den til heap sort• Algoritmen udnytter dermed de bedste egenskaber af heap sort og

quick sort

28

Eksempel på anvendelse: Prioritets køer• En prioritetskø er en datastruktur til vedligeholdelse af et sæt af

elementer, hver med en tilknyttet værdi kaldet en nøgle

• Prioritetskøer anvendes bl.a.• Planlægning af jobs i et operativ system• Håndtering af data trafik• Diskrete event simulatorer• Effektiv søgning af korteste sti i en vægtet graf, f.eks. A* algoritmen.

Prioritetskøen indeholder, efter prioritet, lovende løsninger der skal efterprøves.

• …. 16

14 10

8 7 9 3

2 4 1

1

2 3

4 5 6 7

8 9 10

29

Hvorfor anvende heaps for prioritets køer?

* værste gennemsnitstid

Linked List Binary Tree (Min-)Heap FibonacciHeap

Insert O(1) O(log n) O(log n) O(1)

Accessmin O(n) O(1) O(1) O(1)

Deletemin O(n) O(log n) O(log n) O(log n)*

Decreasekey O(1) O(log n) O(log n) O(1)*

Delete O(n) O(n) O(log n) O(log n)*

Merge O(1) O(m log(n+m)) O(m log(n+m)) O(1)

30

Dagsorden

• To almindelige sorteringsalgoritmer• Heap sort• Quick sort




31

Quick sort

• Del-og-hersk type sorteringsalgoritme

• Del: Opdel arrayet A[p..r] i to del-arrays (potentielt tomme) A1 = A[p..q-1] og A2 = A[q+1..r], således A1 ≤ A[q] ≤ A2Bemærk det er nødvendigt at finde q som en del af denne process

• Hersk: Sorter de to del-array ved et rekursivt kald til quicksort

• Kombiner: Eftersom de sorterede del-arrays er sorteret ved returnering, er kombinering nem: hele arrayet A = [A1 A2] er sorteret.

QUICKSORT (A, p, r)

1 If p < r

2 then q = Partition (A, p, r)

3 Quicksort(A, p, q – 1)

4 Quicksort(A, q + 1, r)

32

Partitionering af arrayet

• Nøglen i algoritmen ligger i at dele arrayet op på en smart måde

• Valg af et pivot punkt, x, hvormed databliver sorteret i de respektive områder

PARTITION (A, p, r)

1 x = A[r]

2 I = p – 1

3 For j = p to (r – 1)

4 do if A[j] ≤ x

5 then i = i +1

6 exchange A[i] «» A[j]

7 exchange A[i+1] «» A[r]

8 Return i + 1

x

≤ x > x ubegrænset

33

To tilfælde af iterationer

• Hvis A[j] > x

• Hvis A[j] ≤ X

>x x

≤ x > x

x

≤ x > x

≤ x x

≤ x > x

x

≤ x > x

34

Eksempel på partitionering af et array

2 8 7 1 3 5 6 4

2 8 7 1 3 5 6 4

2 8 7 1 3 5 6 4

2 8 7 1 3 5 6 4

2 1 7 8 3 5 6 4

2 1 3 8 7 5 6 4

2 1 3 8 7 5 6 4

2 1 3 8 7 5 6 4

2 1 3 4 7 5 6 8

Ekse

mpe

l

35

Ydelsen af Quicksort

• Værste tilfælde• Sker når rutinen deler et problem op i et med hhv. n – 1 og 0 elementer• Antag dette sker i hvert rekursivt kald

• T(0) = Θ(1)• T(n) = T(n – 1) + T(0) + Θ(n) = T(n – 1) + Θ(n)• = Θ(n2)

• Bedste tilfælde • Bedste tilfælde sker når problemet deles op i maksimalt n/2 elementer• Antag dette sker i hver rekursivt kald

• T(n) ≤ 2T(n/2) + Θ(n)• = O(nLog2(n))

36

Gennemsnitsydelsen af quicksort

• Påstand: Gennemsnitsydelsen er tættere på bedste tilfælde, end på værste tilfælde

n

(1/10)n (9/10)n

(1/100)n (9/100)n (9/100)n (81/100)n

1

Log10/9(n)

cn

cn

cn

≤ cn

1

1

≤ cn

Log10(n)

O(nLog(n))

cnnTnTnT ++≤ )10/()10/9()(

Ekse

mpe

l

37

Randomiseret version af quicksort

• Ydelsesanalysen er baseret på at alle permutationer af input muligheder sker med lige stor sandsynlighed

• I virkelighedens verden er dette oftest ikke tilfældet!• Modificering af partitioneringsalgoritmen til

• Ideen er at vælge pivot punktet x tilfældigt, i stedet for altid at vælge x = A[r] (det sidste element i input arrayet)

RANDOM-PARTITION (A, p, r)

1 i = Random(p, r)

2 Exchange A[r] with A[i]

3 Return Partition (A, p, r)

38

Ydelse for randomiseret quicksort

• For værste tilfælde

• I gennemsnit bliver det

)(

)()12()())1(max(

)())1()(()(

2

2

2

22

10

ncn

nnccnnqnccq

nqnTqTMaxnTnq

Θ=

≤

Θ+−−≤

Θ+−−+≤

Θ+−−+=−≤≤

))(()( nnLogOnT =

39

Dagsorden





40

Sortering i (u)linear tid….

• Tidligere har vi set på algoritmer der sorterer i O(n2) eller O(nLog(n)) tid• Kan vi gøre det hurtigere?

• Jo, i lineær tid, dvs. T(n) = O(n)• Hvad er ”problemet” med tidligere sorteringsalgoritmer?

• Vi benytter os af sammenligninger, såsom a1=a2, a1>a2, a1<a2, og opnår et beslutningstræ som f.eks.

• Med eksemplet opnår vi 3! = 6 mulige slutpunkter

1:2

1:32:3

1:3

{3,1,2}{1,3,2}

{1,2,3} {2,1,3}

{2,3,1} {3,2,1}

2:3

>

>

>

≤

≤

≤

≤

≤ >

41

Sortering i (u)linear tid…. #2

• Udførslen af en sorteringsalgoritme baseret på sammenligning er det samme som en sti gennem sådan et træ• Ved hvert blad udføres sammenligningen ai > aj, ai ≤ aj

• Det giver os et sæt af mulige terminerende muligheder• Helt præcist med n elementer bliver det n!

• Længden fra toppen til bunden af et beslutningstræ angiver den værste situation for en sorteringsalgoritme• Fordi den i hver gren skal udføre en sammenligning• En nedre grænse kan findes for kompleksiteten

• Følgende er at heap-sort og merge-sort er asymptotisk optimale sorteringsalgoritmer

42

Dagsorden





43

Counting sort

• Hvad nu hvis vi ikke benytter os af sammenligninger?• Hmmmmm…… hvordan det?• Vi baserer sorteringen på frekvensen (hyppigheden) af tal

• Vi antager her at vi arbejder med numeriske heltals værdier

• Counting sort• A[1..n] : Input array• B[1..n] : Output array. Vi flytter A over i B (sorteret selfølgelig)!• C[0..k] : Midlertidigt array vi benytter til at holde styr på forekomsten

af elementer i A

• Note: så selvom vi kan udføre sorteringen i lineær tid, koster det mere plads i hukommelsen end f.eks. Quicksort!

44

Counting sort #2

• Bemærk:• Linjerne 3 - 4: Her tæller vi hyppigheden af elementer i arrayet A og lægger

dem ind i C• Linjerne 5 - 6: Her danner vi et inkrementerende indeks af hyppighederne• Linjerne 7 - 9: Her foretager vi sorteringen vha. indekseringen

COUNTING-SORT (A, B, k)

1 For i = 0 to k 7 For j = length(A) downto 1

2 do C[i] = 0 8 do B[C[A[j]]] = A[j]

3 For j = 1 to length(A) 9 C[A[j]] = C[A[j]] - 1

4 do C[A[j]] = C[A[j]] +1 //Increment the counter

5 For i = 1 to k

6 do C[i] = C[i] + C[i-1] //Create incremental index

45

Eksempel på eksekvering - optælling i linje 3 - 4

2 5 3 0 2 3 0 31 2 3 4 5 6 7 8

0 1 2 3 4 5 0 1 2 3 4 5

• Samlet tid: T(n) = Θ(k)

0 0 0 0 0 0C

0 0 1 0 0 0C

0 0 1 0 10C

0 0 1 1 10C

1 0 1 1 10C

1 0 2 1 10C

1 0 2 2 10C

2 0 2 2 10C

2 0 2 3 10C

A 2 5 3 0 2 3 0 31 2 3 4 5 6 7 8

A

Ekse

mpe

l

46

Dannelse af indeks

• Generering af en akkumuleret sum danner vores indeks• Samlet tid for generering af indeks: T(n) = Θ(k)• Nu kan vi så begynde at sortere ved flytning af A ind i B vha. C

• B[C[A[j]]] = A[j] i linje 8

2 0 2 3 10

0 1 2 3 4 5

C 2 2 4 7 87

0 1 2 3 4 5

C

2 2 4 7 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3

- - - - - - - -

A

B

1 2 3 4 5 6 7 8

6

3

Ekse

mpe

l

47

- - - - - - 3 -0

Og fortsættelse af indsættelse i B


2 2 4 6 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3A

B

1 2 3 4 5 6 7 8

1

1 2 4 6 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3

- 0 - - - - 3 -

A

B 3

5

1 2 3 4 5 6 7 8

Ekse

mpe

l

48



1 2 4 5 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3

- 0 - - - 3 3 -

A

B

3

2

1 2 3 4 5 6 7 8

1 2 3 5 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3

- 0 - 2 - 3 3 -

A

B

0

0

1 2 3 4 5 6 7 8

Ekse

mpe

l

49

0 0 - 2 - 3 3 -3



0 2 3 5 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3A

B

4

1 2 3 4 5 6 7 8

0 2 3 4 87

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3

0 0 - 2 3 3 3 -

A

B 5

7

1 2 3 4 5 6 7 8

Ekse

mpe

l

50



0 2 3 4 77

0 1 2 3 4 5

C

2 5 3 0 2 3 0 3

0 0 - 2 3 3 3 5

A

B

2

2

1 2 3 4 5 6 7 8

• Samlet tid: T(n) = Θ(n)

Ekse

mpe

l

51

Egenskaber for counting sort

• Samlet tid for udførsel af counting sort• T(n, k) = Θ(n+k)• I praksis har vi at k = O(n), medførende at T(n) = Θ(n)

• Counting sort har derudover et meget vigtigt egenskab• Den er stabil: tal der har samme værdi optræder i samme rækkefølge i

output arrayet, som de gjorde i input arrayet• Det egenskab kan vi udnytte til en mere avanceret form for sortering

52

Dagsorden





53

Radix sort - lidt trivia

• Men først lidt ”moderne” teknologi (ok, så den var moderne i 1925)

• IBMs 80’ serie kunne sortere punch cards• Type 80: 450 cpm (1925)• Type 84: 2000 cpm (>1950) IBM’s serie 80 sorterings maskine fra 1925

FORTRAN udtryk på punch card form: Z = Y + WIBM’s port-a-punch fra 1958

54

Ideen bag radix sort

• Radix sort baserer sig på at sortere tal ved• Først at sortere dem efter mindste ciffer først (enere)• Dernæst næst mindste ciffer (tiere) osv. op til • det højeste ciffer (hundrede)

3 2 9 7 2 0 7 2 0 3 2 9

4 5 7 3 5 5 3 2 9 3 5 5

6 5 7 4 3 6 4 3 6 4 3 6

8 3 9 4 5 7 8 3 9 4 5 7

4 3 6 6 5 7 3 5 5 6 5 7

7 2 0 3 2 9 4 5 7 7 2 0

3 5 5 8 3 9 6 5 7 8 3 9

1 2 3 4

55

Radix sort

• Koden for radix sort er simpel

• Hvis den stabile anvendte sorteringsalgoritme sorterer på Θ(n+k) tid, så sorterer radix sort på Θ(d(n+k)) • Hvis d er konstant og k = O(n) sorterer radix i lineær tid!

• Givet n b-bit numre og for ethvert positiv heltal r ≤ b, sorterer radix-sort korrekt på Θ((b/r)(n+2r)) tid

RADIX-SORT (A, d)

1 For i = 1 to d

2 do Use Stable Sort to sort Array A on digit i

56

Dagsorden





57

Bucket sort

• Baserer sig på et koncept om at inddele data i passende ”buckets”og sortere de enkelte ”buckets”

• Efter sortering i de enkelte ”buckets” grupperes resultaterne i et dermed sorteret array

COUNTING-SORT (A)

1 n = length(A)

2 For i = 1 to n

3 do insert A[i] into list B[[nA[i]]

4 For i = 0 to n -1

5 do sort list B[i] with insertion-sort

6 Concatenate lists B[0], B[1], …, B[n-1] in order

58

Bucket sort - eksempel

0.17 /

0.23 0.26 /

0.78 /

/

/

/

/

1

2

3

4

5

6

7

8

9

0

B

0.12

0.21

0.68 /

0.72

0.94 /

0.39 /

0.78

0.17

0.39

0.26

0.72

0.94

0.21

0.12

0.23

0.68

A

1

2

3

4

5

6

7

8

9

10

0.12

0.17

0.21

0.23

0.26

0.39

0.68

0.72

0.78

0.94

C

1

2

3

4

5

6

7

8

9

10

Ekse

mpe

l

59

Bucket sort - tidskompleksitet

• Antager at input er tal genereret af en stokastisk process, der distribuerer data uniformt i intervallet [0, 1)

• Samtlige kode linjer tager O(n) tid, med undtagelsen af kaldet til Insertion-Sort der som sagt tager O(n2) tid

• Men hvordan kan vi sige en algoritme kører i lineær tid, O(n), når selve sorteringen sker i kvadratisk tid, O(n2)?

• Det kan vi i princippet heller ikke, men vi kan sige den kører i forventet lineær tid, Θ(n)

60

Det var så det, eller …. ???

61

Dagsorden





62

Opsummering og konklusion

• Sorteringsalgoritmer i ulineær tid• Heap sort (O(nLog2(n))• Quick sort (Θ(n2), men typisk O(nLog2(n))

• Sorteringsalgoritmer i lineær tid• Counting sort (Θ(n+k), men typisk O(n))• Radix sort (afhængig af sorteringsalgoritme, men ved f.eks. Counting

sort, kan man opnå at T(n) = O(n))• Bucket sort (gennemsnitligt O(n), men egentlig O(n2))

• Husk også der er flere parametre end tid, f.eks. hukommelsesforbrug der spiller ind i valget af algoritme

63

Dagsorden





64

Opgaver

• Øvelse 6.1-3, 6.1-6, 6.2-1, 6.3-1, 6.4-1, 6.5-1, 6.5-2

• Øvelse 7-1

• Øvelse 8-3

• Ekstra/alternative• Redegør for hvorfor den største undergren i en heap er 2n/3 (slide 12)• Redegør for hvorfor en n-element heap har højden h = Log2(n) og allerhøst

n/2h+1 knuder (slide 20)

mm5: sorting algorithms - november 1,...

Documents