Föreläsning 11 Innehåll

Transkript

1 Föreläsning 11 Innehåll Sortering O(n 2 )-algoritmer: urvalssortering insättningssortering O(n log n)-algoritmer: Mergesort Quicksort Heapsort behandlades i samband med prioritetsköer. Undervisningsmoment: föreläsning 11, övningsuppgifter 12 Avsnitt i läroboken: , , 8.7, 8.9 I gamla upplagan: , , 10.7, 10.9 PFK (Föreläsning 11) HT / 36

2 Sortering Varför sortera? För att göra sökning effektivare. För att förenkla vissa algoritmer. Varför olika sorteringsalgoritmer? Olika sorteringsalgoritmer passar bra i olika sammanhang. Ingen enskild algoritm är bäst i alla möjliga situtioner. PFK (Föreläsning 11) HT / 36

3 Sortering i Java I klassen java.util.arrays finns metoder för att sortera vektorer t ex: public static void sort(int[] items) public static void sort(object[] items) elementen jämförs med compareto public static <T> void sort(t[] items, Comparator<? super T> comp) elementen jämförs med comp.compare Exempel: int[] a = {1, 4, 1, 9, 5, 2, 6}; Arrays.sort(a); I klassen java.util.collections finns metoder för att sortera listor (t.ex. listor av typen ArrayList och LinkedList). PFK (Föreläsning 11) HT / 36

4 Sortering i Java Comparable Person[] a = new Person[5]; a[0] = new Person("C", "2"); a[1] = new Person("B", "1"); a[2] = new Person("A", "3"); a[3] = new Person("D", "5"); a[4] = new Person("E", "4");... Arrays.sort(a);... Klassen Person måste implementera interfacet Comparable. Inuti metoden sort används compareto för att jämföra elementen. PFK (Föreläsning 11) HT / 36

5 Sortering i Java Comparator Person[] a = new Person[5]; a[0] = new Person("C", "2"); a[1] = new Person("B", "1"); a[2] = new Person("A", "3"); a[3] = new Person("D", "5"); a[4] = new Person("E", "4");... Arrays.sort(a, new NameComparator());... Klass som implementerar interfacetcomparator: public class NameComparator implements Comparator<Person> { public int compare(person p1, Person p2) { return p1.getname().compareto(p2.getname()); } } Inuti metoden sort används compare för att jämföra elementen. PFK (Föreläsning 11) HT / 36

6 Sortering i Java Lambdauttryck Person[] a = new Person[5]; a[0] = new Person("C", "2"); a[1] = new Person("B", "1"); a[2] = new Person("A", "3"); a[3] = new Person("D", "5"); a[4] = new Person("E", "4");... Arrays.sort(a, (p1,p2)-> p1.getname().compareto(p2.getname()));... Istället för att skriva en klass som implementerar interfacet Comparator kan vi använda ett lambdauttryck. Inuti metoden sort används compare för att jämföra elementen. PFK (Föreläsning 11) HT / 36

7 Urvalsortering i vektor Urvalsortering (eng. selection sort) Sök minsta elementet i den osorterade delen av vektorn och byt plats med första osorterade element (first = första elementet i den osorterade delen): first first min 2.8 first first min min first min 4.5 min Tidsomplexitet: n 1 + n = O(n 2 ) PFK (Föreläsning 11) HT / 36

8 Urvalssortering Tidskomplexitet är O(n 2 ). Efter k pass är de k minsta (eller största) elementen sorterade. Kan därför vara lämplig om man bara vill få fram de k minsta (eller största) och k är litet. Tidskomplexitet är då O(k n) En bättre (effektivare) variant av urvalssortering är att använda en prioritetskö: Placera elementen i en prioritetskö (n st. offer). Minsta elementet tas sedan successivt ut (n st. poll). eller Bygg heap och sortera på plats i vektorn (Heapsort). Tidskomplexiteten blir i bägge fallen O(n log n). PFK (Föreläsning 11) HT / 36

9 Insättningssortering i vektor Insättningssortering (eng. insertion sort) Element på plats k i vektorn sätts in på rätt plats bland de redan sorterade elementen på platserna 0..k 1 Detta görs för k = 1, 2,..., n sort osort 6.2 sort osort 2.8 sort osort 5.0 sort osort 1.1 sort osort 4.5 sort 6.2 Tidskomplexitet (värstafall): n 1 = n(n 1)/2 = O(n 2 ). Även medelfallet kan visas vara O(n 2 ). PFK (Föreläsning 11) HT / 36

10 Insättningssortering public static <T extends Comparable<? super T>> void sort(t[] a) { for (int i = 1; i < a.length; i++) { T nextval = a[i]; int nextpos = i; while (nextpos > 0 && nextval.compareto(a[nextpos - 1]) < 0) { a[nextpos] = a[nextpos - 1]; nextpos--; } a[nextpos] = nextval; } } PFK (Föreläsning 11) HT / 36

11 Insättningssortering Tidskomplexitet är O(n 2 ) i värsta fall och i medelfall. Dock bra metod om vektorn är nästan sorterad från början: Om vektorn är sorterad utförs bara en jämförelse per pass tidskomplexiteten blir då O(n). Om vektorn består av n sorterade element följda av k osorterade behövs endast k pass. Man börjar med att sortera in det (n + 1):a sedan det (n + 2):a o s v. I varje pass görs i värsta fall O(n) jämförelser. Totalt O(k n) d.v.s. O(n) om k är litet i förhållande till n. PFK (Föreläsning 11) HT / 36

12 Mergesort Sortera med söndra- och härskateknik Sortera vänstra halvan Sortera högra halvan Samsortera de båda sorterade halvorna PFK (Föreläsning 11) HT / 36

13 Samsortering av sorterade följder algoritm Algoritm Givet två följder v1 och v2 med element sorterade i växande ordning. Samsortera till en följd res. Algoritm: i = j = k = 0 så länge det finns obehandlade element kvar i både v1 och v2 jämför elementet i v1[i] med elementet i v2[j] om det minsta elementet är från v1 res[k] = v1[i] i = i + 1 annars res[k] = v2[j] j = j + 1 k = k + 1 En av följderna v1 och v2 har obehandlade element kvar. Flytta dessa element till res. PFK (Föreläsning 11) HT / 36

14 Samsortering av sorterade följder exempel v v v v v v v v res res 1 res 1 2 res v v v v v v res res res v v2 res PFK (Föreläsning 11) HT / 36

15 Samsorteringen i Mergesort I samsorteringssteget i Mergesort (merge) motsvaras de båda följderna v1 och v2 av de båda sorterade vektorhalvorna. Det går inte att utföra samsorteringen i den ursprungliga vektorn. En hjälpvektor, lika stor som den som ska sorteras, behövs. När man i merge-steget skall slå samman två delvektorer: används motsvarande utrymme i hjälpvektorn (tmparray): Resultatet flyttas sedan tillbaka till ursprungsvektorn. PFK (Föreläsning 11) HT / 36

16 Samsorteringen i Mergesort Exempel Slå samman delvektorerna v1 och v2 i vektorn a (bestående av ett element vardera): a tmparray 2 7 Resultatet flyttas sedan tillbaka till den ursprungliga vektorn. a PFK (Föreläsning 11) HT / 36

17 merge implementeringsskiss Slå samman de sorterade delvektorerna a[leftpos].. a[rightpos - 1] och a[rightpos].. a[rightend]: private static <T extends Comparable<? super T>> void merge(t[] a, T[] tmparray, int leftpos, int rightpos, int rightend) { int leftend = rightpos - 1; int tmppos = leftpos;... rightend leftpos rightpos PFK (Föreläsning 11) HT / 36

18 merge implementeringsskiss Forts while (leftpos <= leftend && rightpos <= rightend) { if (a[leftpos].compareto(a[rightpos]) <= 0) { tmparray[tmppos] = a[leftpos]; leftpos++; } else { tmparray[tmppos] = a[rightpos]; rightpos++; } tmppos++; } /* Nu är en av delvektorerna tom. Kopiera över resten av elementen i den icke tomma vektorn till tmparray */ } /* Flytta till sist tillbaks elementen från tmparray till motsvarande platser i a */ PFK (Föreläsning 11) HT / 36

19 Mergesort implementering /** Sorterar elementen i vektora a */ public static <T extends Comparable<? super T>> void sort(t[] a) { T[] tmparray = (T[]) new Comparable[a.length]; mergesort(a, tmparray, 0, a.length - 1); } private static <T extends Comparable<? super T>> void mergesort(t[] a, T[] tmparray, int first, int last) { if (first < last) { int mid = (first + last) / 2; mergesort(a, tmparray, first, mid); mergesort(a, tmparray, mid + 1, last); merge(a, tmparray, first, mid + 1, last); } } PFK (Föreläsning 11) HT / 36

20 Är mergesort stabil? Stabila sorteringsalgoritmer bibehåller ordningen för element med lika nycklar efter sorteringen. Exempel: Antag att vi har personer ordnade efter förnamn: Ada Andersson, Bo Eriksson, Lars Andersson, Lena Andersson Om vi vill sortera efter efternamn istället, men samtidigt bibehålla ordningen mellan förnamnen så måste vi använda en stabil sorteringsalgoritm. Ada Andersson, Lars Andersson, Lena Andersson, Bo Eriksson Är mergesort stabil? PFK (Föreläsning 11) HT / 36

21 Mergesort tidskomplexitet Att samsortera två sorterade delvektorer av sammanlagd storlek n kostar n. 1 merge av två delvektorer av storlek n/2, kostnad n 2 merge av två delvektorer av storlek n/4, kostnad 2 n/2 = n 4 merge av två delvektorer av storlek n/8, kostnad 4 n/4 = n Antal nivåer = log n = total kostnad n log n PFK (Föreläsning 11) HT / 36

22 Quicksort Söndra- och härskaalgoritm. Sämre än Mergesort och Heapsort i värsta fall. Bättre (snabbare) i medelfall. Värstafallet kan göras statistiskt osannolikt. PFK (Föreläsning 11) HT / 36

23 Quicksort algoritm Välj ut ett element (pivotelement). Se till att det hamnar på rätt plats: Flytta om elementen så att element pivot hamnar till vänster och element pivot hamnar till höger. Kallas partitionering av vektorn. x x x Pivot-elementet, på rätt plats Upprepa rekursivt på de båda delvektorerna till vänster respektive till höger om pivotelementet. PFK (Föreläsning 11) HT / 36

24 Quicksort implementering public static <T extends Comparable<? super T>> void sort(t[] a) { quicksort(a, 0, a.length - 1); } /* Privat hjälpmetod. Sorterar delvektorn a[first]..a[last] */ private static <T extends Comparable<? super T>> void quicksort(t[] a, int first, int last) { if (first < last) { int pivindex = partition(a, first, last); quicksort(a, first, pivindex - 1); quicksort(a, pivindex + 1, last); } } PFK (Föreläsning 11) HT / 36

25 Quicksort val av pivot I princip kan vilket element som helst väljas. Vi börjar för enkelhets skull med att välja första elementet i vektorn. Inte särskilt bra val. Vi återkommer senare med en diskussion om bättre val. PFK (Föreläsning 11) HT / 36

26 Quicksort partitioneringssteget Sök från vänster upp ett element som är pivot. Sök från höger upp ett element som är pivot. Byt plats på dessa. Fortsätt tills hela vektorn genomletats. Pivotelementet kan sättas in mellan de båda vektordelarna som uppstår. Arbetet blir proportionellt mot vektorns längd. PFK (Föreläsning 11) HT / 36

27 Partitionering exempel pivot = Efter byte: Efter byte: Byt plats på detta och pivot pivot PFK (Föreläsning 11) HT / 36

28 Partitionering sorterad vektor Dåligt val av pivot Om vektorn är sorterad och om pivot väljs som första elementet hamnar Quicksort i sitt värsta fall: pivot = Byt plats på detta och pivot pivot Tom vektordel till vänster Alla element utom ett till höger Detta upprepas i alla rekursiva upplagor. PFK (Föreläsning 11) HT / 36

29 Quicksort tidskomplexitet Man kan visa att det bästa fallet för Quicksort är när vektorn delas mitt itu i varje rekursiv upplaga. Då är tidskomplexiteten = O(n log n) x x pivot x Sämsta fall är när den ena delvektorn blir tom i varje rekursiv upplaga. Då är tidskomplexiteten = O(n 2 ) x pivot x PFK (Föreläsning 11) HT / 36

30 Quicksort bättre val av pivot Välj median av första, mittersta och sista elementet. Eliminerar riskerna i samband med sorterad eller nästan sorterad indata left mid right Sortera de tre elementen i växande ordning: left mid right pivot Median av de tre är nu mittelementet. PFK (Föreläsning 11) HT / 36

31 Quicksort bättre val av pivot Forts Byt elementet på plats mid med elementet på plats left. Då hamnar pivotelementet längs till vänster precis som förut pivot Nu kan partitioneringssteget utföras som förut. PFK (Föreläsning 11) HT / 36

32 Varianter av partitioneringssteget Stanna eller ej (och byta) vid likhet med pivot? Om vi inte stannar och byter och alla nycklar är lika hamnar vi i sämsta fallet pivot Om vi stannar och byter och alla nycklar är lika blir det bästa fallet pivot Man brukar rekommendera att stanna och byta vid likhet. PFK (Föreläsning 11) HT / 36

33 Quicksort efter partitioneringen Efter partitioneringen sorteras delvektorerna a[low]... a[pivindex-1] och a[pivindex+1]... a[high] rekursivt. I praktiken låter man av effektivitetsskäl metoden avstanna när delvektorn i det rekursiva anropet är mindre än Den då nästan färdigsorterade vektorn kan sorteras av någon metod som är bra på nästan sorterad indata. T.ex. är insättningssortering lämplig. PFK (Föreläsning 11) HT / 36

34 Sortering - sammanfattning Urvalssortering O(n 2 ) Långsam för stora n. Efter k pass är de k minsta sorterade. Insättningssortering O(n 2 ) Bra för nästan sorterad indata (linjär då). Heapssort O(n log n) Kan utformas så att inget extra minnesutrymme krävs. I praktiken långsammare än Quicksort. Efter k pass är de k största elementen sorterade. Mergesort O(n log n) Kräver extra minnesutrymme. I praktiken långsammare än Quicksort. Kan utformas iterativt och användas för att sortera element som finns på fil. Quicksort O(n log n) Men O(n 2 ) i värsta fall. Inget extra minnesutrymme för temporär vektor krävs. Bäst av de nämnda i praktiken om man väljer pivot och utför partitionering förnuftigt. PFK (Föreläsning 11) HT / 36

35 Sortering Exempel på vad du ska kunna Redogöra för och jämföra olika sorteringsalgoritmer: Insättningssortering i vektor Urvalssortering i vektor Heapsort (behandlas i samband med prioritetsköer). Mergesort Quicksort Genomföra sortering på enkla exempel med ovan nämnda metoder Samsortera två sorterade följder Förklara begreppen pivot-element och partitionering (Quicksort). Använda idéerna från sorteringsalgoritmerna för att lösa andra problem (t.ex. partionering från quicksort eller sammanslagning av sorterade följder från mergesort (se t.ex. övningsuppgifter 13). PFK (Föreläsning 11) HT / 36

36 Datorlaboration 6 Använda en map för att implementera en telefonkatalog. Grafiskt användargränssnitt med menyer för att hantera telefonkatalogen. Innehåll: ADT Map, använda klasser från java.util, JavaFX. PFK (Föreläsning 11) HT / 36