TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 5 Jonas Lindgren, Institutionen för Datavetenskap, LiU På denna föreläsning: Algoritmanalys Tidskomplexitet, Rumskomplexitet Ordo, Theta, Omega 1
Algoritmanalys public static void algorithm(int[] numbers) { int tmp; for (int i = 1; i < numbers.length; ++i) { for (int j = numbers.length; j >= i; ++j) { if (numbers[i] < numbers[j]) { tmp = numbers[i]; numbers[i] = numbers[j]; numbers[j] = tmp; Korrekt resultat? Ger alltid lösning (oändlig loop)? Hur snabb är den? Hur mycket extra minne kräver den? 2
Komplexitetsanalys Hur effektiv är algoritmen? I fråga om tid I fråga om extra minnesutrymme Med olika typer av indata Är det teoretiskt möjligt att konstruera en ännu effektivare algoritm för samma problem? 3
Exempel två algoritmer Gissa talet: Givet att det rätta svaret ligger mellan 0 och n, gissa vilket nummer jag tänker på Vid varje gissning svarar jag rätt, för stort eller för litet Försök få rätt svar på så få gissningar som möjligt 0, 1, 2, 3... 50, 75, 62, 68... 4
Komplexitetsteori Grundkrav: En algoritm ska fungera för indata av godtycklig storlek (n) Beräkna körtiden som en funktion av storleken på indata T(n) Fokusera på värsta fallet Ignorera konstanta faktorer Analysen ska vara maskinoberoende Kraftfulla maskiner ökar hastigheten med en konstant Fokusera på dominerande faktorer vid stora indata Skalbarhet (asymptotiska beteendet) 5
Primitiva operationer En primitiv operation antas ta konstant tid: Tilldelning, ex. x = y; Metodanrop (endast själva anropet), ex. foo(); aritmetiska operationer, ex. x+5; Jämförelser, ex. x < 5; Arrayindexeringar, ex. myarray[5]; Objektreferering, ex. myobject.name; Metodretur, ex. return 5; (dvs. punkten!) Låt T(n) vara antalet primitiva operationer som en funktion av storleken på indata 6
Analys... (1) public static int harrysalgorithm(int number, int n) { int guess = 0; 1 while(guess!= number && guess < n){ 1+1+1=3 guess = guess + 1; 5*n 1+1=2 return guess; 1 T Harry (n) = 5*n + 2 7
Analys... (2) public static void annasalgorithm(int number, int n) { int start = 0; int end = n; while (start <= end) { int mid = (start+end)/2; if (mid == number) { 1 1 1 1+1+1=3 1 return mid; //wohoo! ej intressant (ej värstafall) if (mid < number) { 1 start = mid + 1; 8*log 2 (n) else { endast en per varv max(2,2)=2 end = mid - 1; T Anna (n) = 8*log 2 (n) + 2 8
Jämförelse mellan analyser Studera körtiden som en funktion över storleken på indata När är två algoritmer lika effektiva? När är en bättre än en annan? T Harry (n) = 5*n + 2 T Anna (n) = 8*log 2 (n) + 2 9
Ordo(1) Definition: Givet två funktioner f(n) och g(n) Om det finns positiva konstanter c och n 0 sådana att f(n) cg(n) för n n 0 Då f(n) O(g(n)) (dvs. f(n) tillhör Ordo(g(n)) T Harry (n) = 5*n + 2 T Anna (n) = 8*log 2 (n) + 2 Antagande: g(n) = n 5n +2 cn (c-5)n 2 n 2 c 5 låt c = 6, n 0 =2 => 5n + 2 6n för n 2 => T Harry (n) O(n) Antagande: g(n) = n 8log 2 (n) + 2 cn 8 log c 2(n)) + 2 n c låt c = 8, n 0 =2 => 8log 2 (n) + 2 8n för n 2 =>T Anna (n) O(n) 10
Ordo(2) Båda algoritmerna tillhör O(n), tillhör de O(log(n))? T Harry (n) = 5*n + 2 T Anna (n) = 8*log 2 (n) + 2 Antagande: g(n) = log 2 (n) 5n +2 c log 2 (n) 5n log 2 (n) + 2 log 2 (n) c Håller inte för något c då lim n -> (dominerande faktor) Antagande: g(n) = log 2 (n) 8log 2 (n) + 2 clog 2 (n) 8log 2 (n) clog 2 (n) 2 2 8 c log 2 (n) låt c = 10, n 0 =2 => 8log 2 (n)+2 10log 2 (n) för n 2 => T Harry (n) O(log(n)) =>T Anna (n) O(log(n)) 11
Asymptotisk storlek spelar roll... Vid tillräckligt stora probleminstanser n 3n 3 19500000n 10 3 mikrosekunder 200 ms 100 3 ms 2s 1000 3 s 22 s 2 500 50 s 51 s 10 000 49 min 3.2 min 1 000 000 95 år 5.4 tim 12
Ordoklasser Ordo Benämning O(1) Konstant O(log(n)) Logaritmisk O(n) Linjär O(nlog(n)) O(n 2 ) Kvadratisk O(n 3 ) Kubisk O(2 n ) Exponentiell O(n!) Faktoriell O(n x ) Polynomisk Tidskomplexitet: O(n) > O(log(n)) Nu har vi visat vilken algoritm som är effektivast! 13
Räkneregler O(a(n) + b(n)) O( max(a(n), b(n)) ) log a (n) = (1/log b (a)) * log b (n) Basen spelar ingen roll Om f(x) O(log(n)+3) => O(log(n)) => f(x) O(n) välj den som beskriver algoritmen bäst Låt funktionen a O(g) och b O(h) Då gäller a*b O(gh) a+b O(g + h) O(max(g, h)) 14
Omega och Theta Givet två funktioner f och g f tillhör Ω(g) om det finns två positiva konstanter c, n 0 sådana att f(n) cg(n) för n n 0 Ω(g) är en undre gräns för funktionen, jmf. O(g) Givet två funktioner f och g f tillhör Θ(g) om f tillhör Ω(g) och O(g) O Ordo Θ Theta Ω Omega 15
Enklare metod public static void algorithm(int[] numbers) { int tmp; for (int i = 1; i < numbers.length; ++i) { for (int j = numbers.length; j >= i; ++j) { if (numbers[i] < numbers[j]) { tmp = numbers[i]; 1 numbers[i] = numbers[j]; numbers[j] = tmp; T alg (n) O(n 2 ) n n 2 16
Indatas innehåll kan påverka Beror ej bara på indatas storlek, utan även innehållet Värstafallet Bästafallet Medelfallet Amorterad analys Oftast analyseras värstafallet Ibland missvisande 17
Rumskomplexitet Mäter hur mycket extra minne algoritmen allokerar förutom indatat int[] tmp = new int[10000000] => O(1) int[] tmp = new int[n.length*2] => O(n) int[][] tmp = new int[n.length][n.length] => O(n 2 ) Harrys och Annas algoritmer har båda konstant rumskomplexitet 18
Problemkomplexitet Ett problems inneboende komplexitet är den minsta komplexiteten av alla algoritmer som kan lösa problemet Sökning i sorterad array (Harry och Annas problem) => O(log(n)) Sökning i osorterad array => O(n) En algoritm med samma komplexitet som problemet är optimal Vinnare: Anna, med en optimal algoritm med konstant rumskomplexitet! 19