Mm5: Sorting algorithms - November 1,...
Transcript of Mm5: Sorting algorithms - November 1,...
![Page 1: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/1.jpg)
1
Algorithms and Architectures IRasmus Løvenstein Olsen (RLO)
Mm5: Sorting algorithms- November 1, 2010
![Page 2: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/2.jpg)
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
![Page 3: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/3.jpg)
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”
![Page 4: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/4.jpg)
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
![Page 5: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/5.jpg)
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
![Page 6: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/6.jpg)
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
![Page 7: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/7.jpg)
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))
![Page 8: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/8.jpg)
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)
![Page 9: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/9.jpg)
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
![Page 10: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/10.jpg)
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
![Page 11: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/11.jpg)
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
![Page 12: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/12.jpg)
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
![Page 13: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/13.jpg)
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)
![Page 14: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/14.jpg)
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
![Page 15: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/15.jpg)
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
![Page 16: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/16.jpg)
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
![Page 17: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/17.jpg)
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
![Page 18: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/18.jpg)
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
![Page 19: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/19.jpg)
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
![Page 20: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/20.jpg)
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)).
![Page 21: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/21.jpg)
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)
![Page 22: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/22.jpg)
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
![Page 23: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/23.jpg)
23
Heap sort – grafisk gennemgang
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
![Page 24: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/24.jpg)
24
Heap sort – grafisk gennemgang
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
![Page 25: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/25.jpg)
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
![Page 26: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/26.jpg)
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
![Page 27: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/27.jpg)
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
![Page 28: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/28.jpg)
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
![Page 29: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/29.jpg)
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)
![Page 30: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/30.jpg)
30
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
![Page 31: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/31.jpg)
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)
![Page 32: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/32.jpg)
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
![Page 33: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/33.jpg)
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
![Page 34: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/34.jpg)
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
![Page 35: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/35.jpg)
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))
![Page 36: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/36.jpg)
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
![Page 37: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/37.jpg)
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)
![Page 38: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/38.jpg)
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 =
![Page 39: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/39.jpg)
39
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
![Page 40: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/40.jpg)
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
>
>
>
≤
≤
≤
≤
≤ >
![Page 41: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/41.jpg)
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
![Page 42: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/42.jpg)
42
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
![Page 43: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/43.jpg)
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!
![Page 44: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/44.jpg)
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
![Page 45: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/45.jpg)
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
![Page 46: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/46.jpg)
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
![Page 47: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/47.jpg)
47
- - - - - - 3 -0
Og fortsættelse af indsættelse i B
• B[C[A[j]]] = A[j] i linje 8
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
![Page 48: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/48.jpg)
48
Og fortsættelse af indsættelse i B
• B[C[A[j]]] = A[j] i linje 8
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
![Page 49: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/49.jpg)
49
0 0 - 2 - 3 3 -3
Og fortsættelse af indsættelse i B
• B[C[A[j]]] = A[j] i linje 8
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
![Page 50: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/50.jpg)
50
Og fortsættelse af indsættelse i B
• B[C[A[j]]] = A[j] i linje 8
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
![Page 51: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/51.jpg)
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
![Page 52: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/52.jpg)
52
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
![Page 53: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/53.jpg)
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
![Page 54: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/54.jpg)
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
![Page 55: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/55.jpg)
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
![Page 56: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/56.jpg)
56
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
![Page 57: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/57.jpg)
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
![Page 58: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/58.jpg)
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
![Page 59: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/59.jpg)
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)
![Page 60: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/60.jpg)
60
Det var så det, eller …. ???
![Page 61: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/61.jpg)
61
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
![Page 62: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/62.jpg)
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
![Page 63: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/63.jpg)
63
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
![Page 64: Mm5: Sorting algorithms - November 1, 2010kom.aau.dk/~rlo/lectures/algoAndArchI_2010/mm5_full.pdf · 3 Sortering af data • Sortering af data sker mange steder • Data baser •](https://reader030.fdocuments.net/reader030/viewer/2022040800/5e354130f6592e6a1a19401f/html5/thumbnails/64.jpg)
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)