Sorterings-Algoritmer

1. Sorterings-Algoritmer Algoritmer og Datastrukturer

2. Hva er sortering? • Input: en sekvens av N nummer • Output: reorganisering input-sekvensen slik at: • Vi søker algoritmer som gjør dette på en korrekt og effektiv måte. a1 < a2 < a3 ... < an-1 < an

3. Hvorfor sortering? • Den største grunnen til at det er så viktig å kunne sortere et sett av elementer er at mange andre problem blir lettere å løse dersom elementene er sortert

4. Applikasjoner til sortering • Søking: Binær søking finner ut om et element er i en ordliste i O(lg n) tid • Å gjøre søking raskere er vel det viktigste bruksområdet til sortering • Nærmeste nabo: Gitt n nummer, finn paret som er nærmest hverandre • Med en gang nummerene er sortert, vil de nærmeste parene ligge ved siden av hverandre, slik at en O(n) linjær søking gjør jobben

5. Applikasjoner til sortering • Element-Unikhet: Gitt et sett av n elementer, er de alle unike eller finnes der duplikater? • Medianer og seleksjon: Hva er det k-te største elementet i en liste? • Frekvens distrubisjoner: Gitt et sett av n elementer, hvilket element opptrer flest ganger i settet?

6. Hvordan kan vi sortere? • Begrensinger til CPU • Kan bare gjøre en operasjon av gangen, • Siden en sammen-ligning er en operasjon, fører dette til at vi bare kan sammenligne to elementer samtidig når vi skal sortere • Men kan gjøre denne sammenligningen veldig raskt.

7. Repetisjon Trær Sorterings-Algoritmer

8. Trestrukturer: Begreper Rot R B og C’s Mor/Far-node Grener Noder R’s subtre H A D Terminalnode, (endenode, løvnode) B C F G A’s barn (venstre) A’s barn (høyre) Søskennoder

9. 5 ≤ 3 7 ≤ ≤ 2 5 8 Egenskap Binært-Søke-Tre • Et binært søketre er organisert som et binærtre, og har følgende egenskap • Operasjoner på et binært søketre, er derfor proposjonal med høyden på treet O(lg n)

10. Haug-Sortering Sorterings-Algoritmer

11. Hva er en Haug (Heap)? • En haug er et komplett binærtre, • der alle nivå er fylt opp, • untatt eventuelt det siste, • som er fylt opp fra venstre til høyre • En haug brukes til blant annet • Prioritetskøer og til • Haugsortering (Heapsort)

12. i/2 ≥x i x 2i+1 2i ≤x ≤x 16 14 10 8 7 9 3 2 4 1 2 3 4 5 6 7 8 9 Haug : Datastruktur • Binærtre som er lagret i indekserbar variabel (array) Generelle far/barn relasjoner 1 16 2 3 14 10 4 5 6 7 8 7 9 3 8 9 2 4 rot (Heap-egenskapen)

13. 1 16 2 3 4 10 4 5 6 7 14 7 9 3 2 8 ”Max-Heapify”: O(lg n) • Subrutine som vedlikeholder Heap-egenskapen, • ...dvs at barna til roten er mindre enn roten Max-Heapify(A,i) l = left(i) r = right(i) if l ≤ heap-size[A] and A[l] > A[i] then largest = l else largest = i if r ≤ heap-size[A] and A[r] > A[largest] then largest = r if largest ≠ i then exchange A[i]↔ A[largest] Max-Heapify(A,largest) i

14. 1 16 2 3 14 10 4 5 6 7 4 7 9 3 2 8 ”Max-Heapify”: O(lg n) • Subrutine som vedlikeholder Heap-egenskapen, • ...dvs at barna til roten er mindre enn roten Max-Heapify(A,i) l = left(i) r = right(i) if l ≤ heap-size[A] and A[l] > A[i] then largest = l else largest = i if r ≤ heap-size[A] and A[r] > A[largest] then largest = r if largest ≠ i then exchange A[i]↔ A[largest] Max-Heapify(A,largest) 1 i

15. 1 16 2 3 14 10 4 5 6 7 8 7 9 3 2 4 ”Max-Heapify”: O(lg n) • Subrutine som vedlikeholder Heap-egenskapen, • ...dvs at barna til roten er mindre enn roten Max-Heapify(A,i) l = left(i) r = right(i) if l ≤ heap-size[A] and A[l] > A[i] then largest = l else largest = i if r ≤ heap-size[A] and A[r] > A[largest] then largest = r if largest ≠ i then exchange A[i] ↔ A[largest] Max-Heapify(A,largest) 1 i

16. 4 1 3 2 16 9 10 Build-Max-Heap : O(n) • Lager en heap fra en (ikke-ordnet) array, • i angir de indre nodene i heap’en Eksempel 1 Build-Max-Heap(A) heap-size[A] = length[a] for i = [length[a]/2] downto 1 do heapify(A,i) 4 i 2 3 1 3 4 5 6 2 16 9 10

17. 4 1 3 2 16 9 10 Build-Max-Heap : O(n) • Lager en heap fra en (ikke-ordnet) array, • i angir de indre nodene i heap’en Eksempel 1 Build-Max-Heap(A) heap-size[A] = length[a] for i = [length[a]/2] downto 1 do heapify(A,i) 4 2 3 i 1 3 4 6 7 2 16 9 10

18. 4 1 3 2 16 9 10 Build-Max-Heap : O(n) • Lager en heap fra en (ikke-ordnet) array, • i angir de indre nodene i heap’en Eksempel 1 i Build-Max-Heap(A) heap-size[A] = length[a] for i = [length[a]/2] downto 1 do heapify(A,i) 4 3 16 10 4 5 6 7 2 1 9 3

19. 4 1 3 2 16 9 10 Build-Max-Heap : O(n) • Lager en heap fra en (ikke-ordnet) array, • i angir de indre nodene i heap’en Eksempel 1 Build-Max-Heap(A) heap-size[A] = length[a] for i = [length[a]/2] downto 1 do heapify(A,i) 16 3 4 10 4 5 6 7 2 1 9 3

20. Heapsort-Algoritmen • Prosedyre for løsning • Lag heap av tallene (i arrayet) • For tall = [lengden til arrayet] ned til 2 • Bytt første tall med array[tall] • Reetabler treet forarray[1...tall-1] • Ferdig sortert Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1)

21. Eksempel 14 8 7 2 4 1 Heapsort : O(n*lg n) • Kjøretid til heapsort • Heapsort tar O(n*lg n) tid • Siden kallet til Build-Max-Heap tar O(n) tid og • Hver av de n-1 kallene til Heapify tar O(lg n) tid Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1) 16 4 10 2 1 9

22. 14 8 7 i 2 4 1 (1) Eksempel 14 8 7 2 4 1 1 Max-Heapify(A,1) 8 7 2 4 14 (2) Heapsort : O(n*lg n) Usortert Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1) 8 4 1 Kapplinje 2 1 14 (2)

23. Eksempel 14 8 7 2 4 1 Heapsort : O(n*lg n) Usortert 8 Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1) 4 7 2 1 14 (2) i 7 1 Max-Heapify(A,1) 4 1 4 7 Kapplinje 2 8 14 (3) 2 8 14 (3)

24. Eksempel 14 8 7 2 4 1 Heapsort : O(n*lg n) Usortert 7 Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1) 4 1 2 8 14 (3) i 4 2 Max-Heapify(A,1) 2 1 4 1 Kapplinje 7 8 14 (4) 7 8 14 (4)

25. Eksempel 14 8 7 2 4 1 Heapsort : O(n*lg n) Usortert 4 Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1) 2 1 i 7 8 14 (4) 2 1 Max-Heapify(A,1) 1 4 2 4 Kapplinje 7 8 14 (5) 7 8 14 (5)

26. Sortert : A Eksempel 14 1 8 2 7 4 7 2 4 8 1 14 Heapsort : O(n*lg n) Usortert 2 Heapsort(A) for i = [length[a]] downto 2 do exchange A[1]↔ A[i] heap-size[A] = heap-size[A]-1 Max-Heapify(A,1) i 1 4 7 8 14 (5) 1 1 Max-Heapify(A,1) 2 4 2 4 Kapplinje 7 8 14 (3) 7 8 14 (2)

27. Prioritetskøer bruker Heap • Haugsortering er en glimrende algoritme, men en god implementasjon av quicksort, slår den som regel i praksis • Men selve heap-data-strukturen har et stort bruksområde. • Den mest populære applikasjonen til en heap er å bruke den som en prioritetskø.

28. Prioritetskøer bruker Heap • En prioritetskø er en datastruktur for å holde vedlike et sett av S elementer, • ...der hvert element har en assosiert verdi • En har to typer prioritetskøer: • En max-prioritets-kø • En min-prioritets-kø

29. Prioritets-kø : Operasjoner • Operasjoner til en max-prioritets-kø • Insert(S,x), kjøretid O(lg n) • setter et element x inn i settet S • Setter en node inn i heapen • Maximum(S), kjøretid O(1) • returnerer elementet S med den største verdien • Extract-Max(S), kjøretid O(lg n) • Returnerer elementet S med den største verdien • ...og fjerner elementet fra heapen

30. Prioritets-kø : Operasjoner • Operasjoner til en max-prioritets-kø • Increase-Key(S,x,k), kjøretid O(lg n) • Øker verdien til et element x til en ny verdi k, • ...som en antar er minst like stor som x • Operasjoner til en min-prioritets-kø • Insert(S,x), Minimum(S), Extract-Min(S), Decrease-Key(S,x,k)

31. Merge-Sortering Sorterings-Algoritmer

32. Hva er Merge-Sort? • Merge-sortering (flette-sortering) er basert på ”splitt-og-hersk”-paradimet • Splitt: del arrayet med n elementer i 2 deler med n/2 elementer • Hersk: sorter de to halvdelene rekursivt ved kall til ”mergesort” • Kombiner: flett sammen de to halvdelene for å produsere det sorterte arrayet

33. 5 2 4 6 1 3 2 6 5 2 4 6 1 3 2 6 5 2 4 6 1 3 2 6 2 5 4 6 1 3 2 6 2 4 5 6 1 2 3 6 1 2 2 3 4 5 6 6 Merge-Sort : Algoritmen Merge-Sort(A,p,r) if p <r then q = [(p+r)/2] Merge-Sort(A,p,q) Merge-Sort(A,q+1,r) Merge(A,p,q,r) splitt 5 2 4 6 1 3 2 6 Dette gir oss rekurrensen: hersk kombiner T(n) = 2T(n/2) + c*n) O(n*lg n)

34. A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. minste minste A hjelpearray

35. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G hjelpearray

36. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G H hjelpearray

37. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G H I hjelpearray

38. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G H I L hjelpearray

39. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G H I L M hjelpearray

40. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G H I L M O hjelpe array

41. minste minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. A G H I L M O R hjelpearray

42. minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. Første halvdel ferdig A G H I L M O R S hjelpearray

43. minste A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. Første halvdel ferdig A G H I L M O R S T hjelpearray

44. A G L O R H I M S T Merging • Hold oversikt over det minste elementet i hver sortert halvdel. • Sett inn det minste av de to elementene i det sorterte arrayet • Gjenta dette til du er ferdig. Første halvdel ferdig Andre halvdel ferdig A G H I L M O R S T hjelpearray

45. QuickSort Sorterings-Algoritmer

46. Hva er Quicksort? • Quicksort er basert på ”splitt-og-hersk”-paradimet, slik som merge-sort. • ...men inneholder i tillegg en viktigsubrutinesom heter partition • Kjøretiden til quicksort er • O(n2) i verste tilfelle, men • O(n*lg n) i gjennomsnitt

47. Idê bak partition • Metode som deler arrayet slik at • Elementet a[i] en deler arrayet i er på rett plass • Det ikke er noen større elementer til ventre for i • Det ikke er noen mindre elementer til høyre for i • Deretter sorterer quicksort den venstre og høyre delen rekursivt

48. Q U I C K S O R T I S C O O L partition element ikke partitionert venstre partitioned høyre PartitioningAlgoritme - Velg partition element til å være det lengst til høyre - Scan fra venstre for et større element - Scan fra høyre for et mindre element - Bytt elementer - Gjenta til pekerne krysser - Bitt partition element med ”kryss-elementet”

49. Bytt meg partition element ikke partitionert venstre partitionert høyre PartitioningAlgoritme - Velg partition element til å være det lengst til høyre - Scan fra venstre for et større element - Scan fra høyre for et mindre element - Bytt elementer - Gjenta til pekerne krysser - Bitt partition element med ”kryss-elementet” Q U I C K S O R T I S C O O L

50. Bytt meg partition element ikke partitionert venstre partitionert høyre PartitioningAlgoritme - Velg partition element til å være det lengst til høyre - Scan fra venstre for et større element - Scan fra høyre for et mindre element - Bytt elementer - Gjenta til pekerne krysser - Bitt partition element med ”kryss-elementet” Q U I C K S O R T I S C O O L