Algoritmer och datastrukturer Föreläsning 8 Tidskomplexitet (Weiss kap Asymptotisk komplexitet Ordobegreppet

Tidskomplexitet Algoritmers körtid mäts i antal operationer: additioner tilldelningar jämförelser … inte i sekunder! Varför? För en given indatastorlek (t.ex. antal element i en lista), hur många operationer utförs? T(n) = f(n)

Exempel: SeqSearch • Om listan har n element behövs (i värsta fall) procedure SeqSearch (List, Value) while ( entries left to be considered) do TestEntry ← next entry from List if ( Value = TestEntry ) then return “success” return “search failed” •  Om listan har n element behövs (i värsta fall) n uppslag n tilldelningar n jämförelser Kan det göras snabbare? T(n) = 3n + 1 operationer! 1 returnering Algoritmer & Datastrukturer, TDA143, VT17, UH

Binärsökning • Om listan är sorterad 1 2 3 4 6 7 9 6 > 4 6 < 7 6 = 6 procedure BinSearch (List, Value) if( List isEmpty ) return “fail” else TestEntry ← middle entry of List if( Value = TestEntry ) return “success” if( Value > TestEntry ) return BinSearch(RightHalfofList, Value) if( Value < TestEntry ) return BinSearch(LeftHalfofList, Value)

Binärsökning (forts.) Antalet halveringar av n saker = log2n Binärsökning kräver bara 5 log2n + 2 operationer i värsta fallet

Asymptotisk komplexitet - Ordo (Big-O) Vanligen räknar man inte exakta antal. Istället beräknar man den asymptotiska komplexiteten - hur antalet operationer växer med storleken på indata! Exempel: Om vi dubblar antalet element, hur mycket längre tid tar det att sortera dem?

g är uppåt begränsad av f Ordobegreppet: Big-O En funktion g(n) är O(f(n)) om det finns en konstant c>0 så att g(n) ≤ c f(n) för alla n ≥ n0 ≥ 0 g är uppåt begränsad av f f(n) g(n) n0

Insättningssortering procedure InsertionSort( List ) N ← 2 while ( N ≤ LengthOfList ) do Select the N:th entry in the List as the pivot Move pivot to a temporary location leaving a hole while( (exists entry left of the hole ) and (entry > pivot) do Move the entry down into the hole Move the pivot into the remaining hole N ← N + 1

Sortering: Tidskomplexitet •  Insättningssortering, grov analys -  Två nästlade for-loopar med som mest n iterationer vardera => T(n) = O(n2) operationer •  Merge sort: T(n) = O(n log n) -  Hur många operationer behövs för att sortera 2n element jämfört med n element med respektive algoritm? - T(2n) = ...

Tidskomplexitet för sekventiell beräkning Tidskomplexiteten hos en sekventiell beräkning är samma som komplexiteten för sekvensens dominerande komponent. S1; S2; Om tidskomplexiteten för S1 är O(f1(M)) och för S2 O(f2(N)) så har sekvensen S1;S2 komplexiteten O(max(f1(M),f2(N))). Ofta är M och N samma variabel, som i exemplet nedan. Ex. Komplexiteten för hela sekvensen nedan är O(N∙log(N)). Inläsning av N element till ett fält; O(N) Sortering av fältet med Quicksort; O(N∙log(N))

Tidskomplexitet för iteration Tidskomplexiteten hos en iteration är produkten av antalet iterationer och maximum av komplexiteten för beräkningen av loopvillkoret och för arbetet som utförs i varje iteration. while ( cond ) S; Om loopen itererar O(fit(N1)) varv och tidskomplexiteten för att beräkna loopvillkoret cond är O(fcond(N2)), och för satsen S, O(fbody(N3)), så har hela loopen komplexiteten O(fit(N1)∙max(fcond(N2),fbody(N3)))

for ( int j = 0; j <= N; j++ ) sum = sum + j; Ex. for ( int j = 0; j <= N; j++ ) sum = sum + j; Här är fit(N) = N, fcond = c1 och fbody = c2 Tidsåtgången för beräkningen av loopvillkoret och satsen beror ej av N utan kan antas ta konstant tid varje gång de utförs (c1 och c2). Hela loopen får därför komplexiteten O(N∙max(c1,c2)) = O(N). for ( int i = 0; i <= M; i++ ) for ( int j = 0; j <= N; j++ ) sum = sum + j; Här är fit(M) = M, fcond = c1 och fbody(N) = O(N) (enligt ovan). Hela loopen får komplexiteten O(M∙max(c1,N)) = O(M∙N). O(M∙N) O(N)

Regler för produkt och summa Sats Låt Då gäller att

Bevis Från (1) och (2) och definitionen av ordo följer att Låt då följer direkt av olikheterna ovan att d.v.s. alltså är

forts. men så av (3) och (4) följer att d.v.s. alltså är v.s.v.

Exempel: Analys av loopar Bestäm tidskomplexiteten T(n) för looparna på bilderna som följer! Försök hitta så snäva övre begränsande funktioner f(n) som möjligt, så att T(n) = O(f(n)).

for ( int i = 0; i < n; i++ ) sum++; // Fragment #1 for ( int i = 0; i < n; i++ ) sum++;

for ( int i = 0; i < n; i += 2 ) sum++; // Fragment #2 for ( int i = 0; i < n; i += 2 ) sum++;

for ( int i = 0; i < n; i++ ) for ( int j = 0; j < n; j++ ) // Fragment #3 for ( int i = 0; i < n; i++ ) for ( int j = 0; j < n; j++ ) sum++;

for ( int i = 0; i < n; i++ ) sum++; // Fragment #4 for ( int i = 0; i < n; i++ ) sum++; for ( int j = 0; j < n; j++)

for ( int i = 0; i < n; i++ ) for ( int j = 0; j < n * n; j++ ) // Fragment #5 for ( int i = 0; i < n; i++ ) for ( int j = 0; j < n * n; j++ ) sum++;

for ( int i = 0; i < n; i++ ) for ( int j = 0; j < i; j++ ) // Fragment #6 for ( int i = 0; i < n; i++ ) for ( int j = 0; j < i; j++ ) sum++;

for ( int i = 0; i < n; i++ ) for ( int j = 0; j < n * n; j++ ) // Fragment #7 for ( int i = 0; i < n; i++ ) for ( int j = 0; j < n * n; j++ ) for ( int k = 0; k < j; k++ ) sum++;

for ( int i = 1; i < n; i = i*2 ) sum++; // Fragment #8 for ( int i = 1; i < n; i = i*2 ) sum++;

for ( int i = 0; i < n; i++ ) sum++; // Fragment #9 for ( int i = 0; i < n; i++ ) sum++; for ( int j = 0; j < n * n; j++ )

for ( int j = 1; j < i * i; j++ ) if ( j % i == 0 ) for ( int i = 1; i <= n; i++ ) for ( int j = 1; j < i * i; j++ ) if ( j % i == 0 ) for ( int k = 0; k < j; k++ ) sum++;