deeegimnoorrrsstt Sjette forelesning

Transkript

1 deeegimnoorrrsstt Sjette forelesning 1

2 2

3 Rebus. Hva er dette? Svar: Kvadratiske sorteringsalgoritmer :-> Som vanlig relativt abstrakte beskrivelser her. Ta en titt på pseudokode i boka for mer detaljert arrayelement-skyfling. sorteri ngsalgo ritmer. Nært Brute Force, men ikke helt. Hva vil brute force (type prøv alle muligheter e.l.) være for sortering? 3

4 Merk: Samme mønster som Bellman-Ford, på sett og vis. Tilsynelatende bare overfladisk, men egentlig et generelt mønster. Bubble Sort Normalt: Sammenlign alle par i rekkefølge fra venstre til høyre. Tenk etter: Vil det fungere om du i hver iterasjon fikser parene i tilfeldig rekkefølge? Beviset blir helt klart ikke det samme, men blir det korrekt likevel? Gjenta n ganger: Sammenlign og evt. fiks alle n 1 par Utfør fra venstre til høyre i hver iterasjon. I hver iterasjon vil da det største usorterte elementet ha falt på plass. n iterasjoner gir da fullstendig sortering. 4

5 Selection Sort Gjenta n ganger: Finn det største usorterte elementet Bytt plass med det siste usorterte Nærmest en direkte implementasjon av korrekthetsbeviset til Bubble Sort! 5

6 Insertion Sort Gjenta n ganger Sett inn første usorterte blant sorterte De sorterte havner i starten. Man leter etter riktig plass. Merk at man ofte lar elementet synke ned til riktig plass, så man setter det inn mens man leter. Det kan evt. gjøres ved å bare duplisere neste element hele veien, og så sette inn elementet direkte når man har funnet rett plass. 6 Oppgave : Tenk ut din egen sorteringsalgoritme med kvadratisk kjøretid. Om du ikke klarer det, prøv en med kjøretid på O(2^n) eller O(n!) :)

7 Stå på eksamen uten å lese boka! 7

8 8

9 And I was really impressed with how they managed to shock the Goatse guy. 9

10 Men hvor effektivt kan det bli? Ω(n lg n) 10

11 Se kap. 8 Hver sammenligning halverer antall muligheter. Vi starter med n! mulige rekkefølger. Beste «worst-case» blir lg(n!) Nyttig: Stirlings approksimasjon: n! > (n/e)^n Dermed: h lg(n!) lg(n/e)^n = n lg(n/e) = n lg n - n lg e = Omega(n lg n) 11

12 Med andre ord lg n! = Ω(n lg n) 12

13 Heapsort 13

14 14

15 p(i) = i/2 l(i) = 2i r(i) = 2i

16 Heapify 16

17

18

19

20 På tavla: Kjøretid Korrekthet (invariant) Build-Heap(A, n): for i floor(n/2) downto 1 Heapify(A, i, n) 20

21 Korrekthet vises enkelt induktivt. Eksempel på tavla. Heapsort(A, n): Build-Max-Heap(A, n) for i n downto 2 exchange A[1] and A[i] Max-Heapify(A, 1, i 1) 21

22 Operasjonene forklart på tavla. Viktig: Hvordan elementer kan «flyte» oppover eller «synke» nedover til riktig plass. Insert(S, x) Maximum(S) Extract-Max(S) Increase-Key(S, x, k) 22

23 Sortering «Selection sort» med en heap In-place, enkel O(n lg n) Heapsort 23

24 M g O g r e t r o es Dårlig worst-case, men bra average-case. Lave konstantledd. Mergesort virker på en måte «omvendt». QS er in-place; MS er det ikke. MS har bedre worst-case. Quicksort 24

25 Grunn-idé Korrekthet vises induktivt. Kjøretiden gis av vårt velkjente binærtre. Del sekvensen i to Sorter hver halvdel rekursivt Kombinér etterpå (Mergesort) eller rydd litt først (Quicksort) Te gning/forklar ing på tavla. 25

26 Invariant: 26

27 Invariant: 27

28 Merge Enkelt eksempel på tavla. Du har to sorterte (del-)sekvenser Plukk ett av sekvens-«hodene» Velg hele tiden det minste Legg det inn på neste ledige plass i resultatet 28

29 Kjøretid Worst-case for MS og Best-case for QS T(n) = 2T(n/2) + n Selv 9-til-1-split gir Θ(n log n) for QS Average-case blir også Θ(n log n) Skjev split for QS gir kvadratisk WC Randomisering: Unngår data-avhengig WC 29

30 Average-case Intuisjon: Selv om annenhvert nivå er helt skjevt vil det bare øke kjøretiden med en konstant. 30

31 Sortering Store/små for seg Rekursivt Kjapp O(n 2 ) WC O(n lg n) Avg. Quicksort 31

32 Sortering Splitt og hersk og flett Stabil Ikke in-place O(n lg n) Mergesort 32

33 33

34 34

35 35

36 36

37 37

38 38

39 39

40 Vi slår den nedre grensen ved å «spille et annet spill» Lineær sortering 40

41 Lineær sortering Counting sort 41

42 Inn: A[1 n], der A[i] {0, 1,, k} Ut: B[1 n], sortert Ekstralager: C[0 k] Vi bruker C til å telle forekomster 42

43 Tell hvor mange vi har av hver Gjør telle-tabellen (C) kumulativ Tallet angir nå posisjonen til den siste forekomsten Gå igjennom A (baklengs) og bruk C til å finne posisjon Oppdater C etter hvert (dekrementer posisjonen) 43

44 for i = 0 to k C[i] = 0 for j = 1 to n C[A[j]] = C[A[j]] + 1 for i = 1 to k C[i] = C[i] + C[i 1] for j = n downto 1 B[C[A[j]]] = A[j] C[A[j]] = C[A[j]] 1 Her gjelder det å gå systematisk til verks Her har vi «downto» for å holde sorteringen stabil. Ser du hvorfor det må være sånn? Bonusspørsmål: Klarer du å lage en versjon som *ikke* bruker downto, men som er stabil likevel? 44

45 Kø-sortering En måte å se «koblingen» på er at vi i tellesortering først holder rede på hvor lange køene er, og deretter på En lignende sak hvor køene slutter. En forskjell er at vi henter verdier fra hver kø i tilfeldig rekkefølge. Opprett en FIFO-kø for hver mulig verdi For hvert input-element: Legg bakerst i riktig kø Slå sammen køer Fyll output med verdier fra køen Denne algoritmen er også en svært nær slektning (en slags heltallsvariant) av bøttesortering (forklares litt senere). 45 Dette kan enten ses som en konseptuell forklaring av (nesten) hva som skjer i tellesortering (det kan kreve litt tenking å se «ekvivalensen») eller som en egen, enkel, lineær-tids sorteringsalgoritme.

46 Sorter heltall Eller lignende Verdier O(n) Tell forekomster Regn ut indeks Lineær Strenge krav O(n) Tellesortering 46

47 Lineær sortering Radix sort 47

48 Sorter hvert siffer for seg Bruk en stabil sortering (f.eks. CS) for å bevare arbeidet så langt Vi må begynne med minst signifikante siffer Konstant antall siffer: Lineær kjøretid 48

49 49

50 50

51 Hva om tallene har ulikt antall siffer? Hva om det er veldig stor forskjell? Kan vi få til O(m), der m er det totale antall siffer brukt? (Det ville kunne brukes på vilkårlige strenger også.) Bryter vi i så fall den nedre grensen vår? Korrekthet kan vises ved induksjon på antall pass Kjøretid Θ(n + k) (evt. Θ((n + k)d) Hvordan bryter radix sort reglene for sammenligningssortering? Vi kan få informasjon ut over bare å sammenligne to nøkler. Vi bruker nøkler som tabellindekser! 51 Det kan vi gjøre fordi vi kjenner verdiområdet.

52 Sorter heltall Eller lignende Verdier O(n k ) Sorter siffer Stabilt Lineær Ganske strenge krav O(kn) Radikssortering 52 Evt. gruntallssortering :-)

53 Lineær sortering Bucket sort 53

54 Anta uniformt fordelte verdier i [0,1) Del [0,1) i n like store bøtter Fordél verdiene i bøttene Gå igjennom bøttene i rekkefølge Skriv ut verdiene sortert 54

55 Bøttene sorteres (med en enkel algoritme) Hver bøtte har O(1) forventet størrelse Totalt O(n) kjøretid 55

56 Sortering Uniformt [0,1) Ordnet hashing Lineær Krav O(n) Bøttesortering 56

57 Select 57

58 Seleksjon: Finn i-ende ordens statistic Eksempler: minimum, maksimum, median min/maks: enkle spesialtilfeller Vi ønsker ikke å sortere 58

59 I stedet for å sortere begge halvdeler fortsetter vi bare i den som inneholder posisjon i, som er den vi leter etter. Randomized-Select Eksempel på tavla..5 Quicksort Verste tilfelle blir som for Quicksort. Beste tilfelle blir Theta(n). Forventet kjøretid, forenklet: T(n) = T(n/2) + n 59 Regnes på tavla.

60 Select Hårete og søt 60

61 Del i grupper på 5, og finn medianen i hver Finn «medianen til medianene», rekursivt Bruk denne som pivot i Partition Select rekursivt på «halvparten» Median-av-5: Konstant tid (insertion sort, f.eks.) for hver; O(n) totalt. Median-av-medianer: T(n/5). Merk: Etter utført algoritme vil dataene allerede være partisjonerte rundt elementet vi leter etter. Så ved å kjøre select etter element k så finner vi automatisk de k minste elementene i tabellen. 61 Partition: O(n). Rekursivt kall T(7n/10 + 6), hvis T(n) er monotont stigende. Mao: Vi får en «prosent-deling» i rekursjonen.

62 Finn median Og lignende Halv Quicksort Kjapp O(n 2 ) WC O(n) Avg. Randomized Select 62

63 Finn median Og lignende Pivot = m. av m. finnes rekursivt Kjapp O(n) Select 63