1. Kompleksnost programov in algoritmov

2. Kompleksnost programov
Kompleksnost programov ali algoritmov se večinoma ukvarja s tem, koliko časa potrebuje nek program za svoje izvajanje, koliko virov pri tem uporablja, kako razumljiva je njegova koda.
Tudi najbolj preproste probleme lahko rešujemo z različnimi metodami. Lahko jih tudi kodiramo na različne načine.
Nekatere probleme lahko zakodiramo z več vrsticami, vendar morda isto dosežemo z le nekaj stavki v zanki. Velikost programa torej nima direktne povezave z njegovo kompleksnostjo.
Kompleksnost pogosto navezujemo na urejanje in elementov v seznamih in njihovo iskanje. Sezname elementov lahko preiskujemo zaporedno, lahko pa uporabimo metodo “binarnega razreza”

3. Primer algoritma: Binarno iskanje
Cilj
Iskanje neke vrednosti v zbirki vrednosti
Ideja
Deli in vladaj
Binary Search The binary search algorithm has roughly the same asserted outcome as sequential search, while the assumptions and body are quite different. To understand these differences, return to the example problem of finding a book on a shelf.
Suppose, first, that we are searching for a specific book title. If we arranged the books in alphabetical order by title, we could speed up the search by a test/divide process. We start the search for a certain book title in the middle of the shelf. If the title of the middle book is the one we want, the search is over successfully. If the title we want precedes the middle title, then we know the book we seek must be on the first (left) half of the shelf, otherwise, it must be on the right half (or it might not be there at all). By looking at the middle book, we narrow the search down to one half of the original range. Now we repeat the process, working with the half of the shelf to which the search was narrowed in the previous step. Looking at the book in the middle of the new range, we either find the book we seek, or we narrow the search range again by a factor of two, to 1/4 of the original. Testing again narrows the range to one-half of 1/4, or 1/8. And so on, until we either find the book or deduce that it is not on the shelf. Note that after k steps, the algorithm has reduced the range by a factor of 2k. As soon as 2k equals or excedes the number of books, the process terminates. Note that 2k >= n is equivalent to k >= log2 n.
The process just described is called binary search, probably because it systematically reduces the search range by a factor of 2 at each step. The essential features of the bookshelf we used are:
The books are arranged in order by title (sorted collection).
We can directly access any book (random access).
Note that the order of the books is by title, the same as the item of data for which we are searching. This is a critical point. For example, having the books set up as described will do nothing to speed up our search for the $100 bill. We can test the middle book for the $100, but not finding it will not give us any information about which side of the test book the $100 my reside on. To find the $100, we have to go back to sequential search. Neither being sorted by title nor having direct access will help.

4. Binarno iskanje(2) Zahteve Učinkovitost11 23 35 47 53 60 72 82 91 99
Zahteve
Zbirka mora biti v obliki polja (“array”)
Za skok na poljuben element polja uporabljamo indekse
Zbirka naj bo urejena (sortirana)
Učinkovitost
Zelo hitro iskanje
Ne potrebujemo dodatnega prostora

5. Ideja binarnega iskanja 47
35 <
Iskalno območje: 0 – 7
Iskano število 35

6. Ideja binarnega iskanja 23
< 35
Iskalno območje: 0 – 3
Iskano število: 35

7. Ideja binarnega iskanja 35
== 35
Iskalno območje:
Iskano število 35

8. Kompleksnost programov

9. Primitivne operacije Osnovna računanja, ki jih izvaja algoritem
Odkrijemo jih v psevdo kodi
Precej neodvisne od programskega jezika
Točna definicija niti ni pomembna
Predvidevamo, da potrebujejo konstanten čas izvajanja
Primeri:
Ocenjevanje izraza
Prirejanje vrednosti neki spremenljivki
Indeksiranje polja
Klic metode
Povratek iz metode

10. Štetje primitivnih operacij
S proučevanjem psevdo kode lahko določimo maksimalno število primitivnih operacij, potrebnih za izvedbo algoritma in v funkciji velikosti vhoda
Algoritem: arrayMax (A,n)
currentMax ←A[0]
for (i=1;i<n; i++)
if( A[i] currentMax then
currentMax ← A[i]
return currentMax
Št operacij 2 2n
2(n  1) 1
Skupaj 6n 1
(i = 1 enkrat
, i<n n krat
, i++ (n-1) krat

11. Ocena časa izvajanja
Algoritem arrayMax v najslabšem primeru izvede 6n  1 primitivnih operacij.
Definirajmo:
a = čas, potreben za najhitrejšo primitivno operacijo
b = čas, potreben za najpočasnejšo primitivno operacijo
Naj bo T(n) najslabši čas za arrayMax. Tedaj velja
a (6n  1)  T(n)  b(6n  1)
Torej je T(n) omejen z dvema linearnima funkcijama n
a (6n  1)
b(6n  1)
čas
T(n)

12. Učinkovitost
Če imamo več algoritmov za reševanje danega problema, kateri je najhitrejši?
Če imamo nek algoritem, ali je sploh uporaben oziroma dovolj učinkovit v praksi?
Koliko časa potrebuje nek algoritem?
Koliko pomnilniškega prostora potrebuje nek algoritem?
V splošnem sta tako časovna kot prostorska zahtevnost algoritma odvisna od velikosti njegovega vhoda.
DEMO

13. Učinkovitost: merjenje časa
Merimo čas v sekundah?
+ uporabno v praksi
– odvisno od jezika, prevajalnika in procesorja.
Štetje korakov algoritma?
+ neodvisno od prevajalnika in procesorja
– odvisno od razdrobljenosti korakov.
Štetje značilnih operacij? (n.pr. aritmetičnih oper. v matematičnih algoritmih, primerjanj v iskalnih algoritmih)
+ odvisno od samega algoritma
+ merimo notranjo učinkovitost algoritma.

14. Primer: algoritmi potenciranja(1)
Preprost algoritem potenciranja:
Za izračun bn:
1. Nastavimo p na Za i = 1, …, n, ponavljamo: p  p krat b. 3. Končamo z odgovorom p.

15. Analiza algoritma potenciranja
1. Nastavimo p na Za i = 1, …, n, ponavljamo: p  p krat b. 3. Končamo z odgovorom
p = bn
Analiza (štetje množenj):
Korak 2.1 izvaja množenje. Ta korak ponovimo n krat.
Število množenj = n

16. Implementacija v Javi
static int power (int b, int n) { // Return bn (where n is non-negative). int p = 1; for (int i = 1; i <= n; i++) p *= b; return p; }

17. Primer: Bister algoritem potenciranja
Zamisel : b1000 = b500 ´ b500. Če poznamo b500, lahko izračunamo b1000 z le enim dodatnim množenjem!
Bister algoritem potenciranja:
Za izračun bn:
1. Nastavimo p na 1, nastavimo q na b, nastavimo m na n. 2. Dokler m > 0, ponavljamo: Če je m lih, množimo p  p krat q Razpolovimo m (pozabimo na ostanek) Množimo q  q krat q Končamo z odgovorom p.
DEMO

18. Analiza bistrega algoritma potenciranja
1. Nastavimo p na 1, nastavimo q na b, nastavimo m na n. 2. Dokler m > 0, ponavljamo: Če je m lih, množimo p  p krat q Razpolovimo m (pozabimo na ostanek) Množimo q  q krat q Končamo z odgovorom p.
Analiza (štetje množenj):
Koraki 2.1–2.3 izvedejo skupaj največ 2 množenji. Ponavljamo jih, dokler moramo razpolavljati vrednost m (ob zanemarjanju ostanka), da ta doseže vrednost 0, torej, "floor(log2 n) + 1" krat.
Maksimalno število računanj = 2(floor(log2 n) + 1) = 2 floor(log2 n) + 2

19. Implementacija v Javi
static int power (int b, int n) { // Return bn (where n is non-negative). int p = 1, q = b, m = n; while (m > 0) { if (m%2 != 0) p *= q; m /= 2; q *= q; } return p; }

20. Primerjava algoritmov potenciranja10 20 30 40
število množenj 50 n
preprost algoritem
bister algoritem

21. Performančna analiza
Določanje časovnih in pomnilniških zahtev algoritma.
Ocenjevanju časa pravimo analiza časovne kompleksnosti
Ocenjevanju pomnilniških zahtev pravimo analiza prostorske kompleksnosti.
Ker je pomnilnik cenen in ga imamo kar nekaj, redko izvajamo analizo prostorske kompleksnosti
Čas je “drag” , zato analizo pogosto omejimo na časovno kompleksnost.

22. Kompleksnost
Za veliko algoritmov težko ugotovimo točno število operacij.
Analizo si poenostavimo:
identificiramo izraz, ki najhitreje raste
zanemarimo izraze s počasnejšo rastjo
v najhitreje rastočem izrazu zanemarimo konstantni faktor.
Tako dobljena formula predstavlja časovno kompleksnost algoritma. Osredotočena je na rast časovne zahtevnosti algoritma.
Podobno velja za prostorsko zahtevnost.

23. Časovna kompleksnost algoritma potenciranja
Analiza preprostega algoritma potenciranja (štetje množenj):
Število množenj = n
Čas, potreben za izvedbo, je sorazmeren z n.
Časovna kompleksnost je reda n. To zapišemo kot O(n).

24. Čas.kompleksnost bistrega algoritma pot.
Bister algoritem potenciranja (štetje množenj):
Maks. število množenj = 2 floor(log2 n) + 2
Zanemarimo izraz s počasnejšo rastjo, +2.
Poenostavimo na 2 floor(log2 n)
nato na floor(log2 n)
Zanemarimo konstantni faktor, 2.
nato na log2 n
Časovna kompleksnost je reda log n. kar zapišemo kot O(log n).
Zanemarimo floor(), ki v povprečju odšteje 0.5, kar je konstanta.

25. Primerjava čas. kompleksnosti algoritmov potenc.10 20 30 40 n 50 n
log n

26. Notacija O
Vidimo, da je algoritem O(log n) boljši od algoritma O(n) pri velikih vrednostih n. O(log n) predstavlja počasnejšo rast kot O(n).
Kompleksnost O(X) pomeni “of order X”, torej rast, sorazmerno z X.
Pri tem smo zanemarili izraze s počasnejšo rastjo in konstantne faktorje.

27. Notacija O primeri kompleksnosti
O(1) konstanten čas (izvedljivo)
O(log n) logaritmični čas (izvedljivo)
O(n) linearen čas (izvedljivo)
O(n log n) log linear čas (izvedljivo)
O(n2) kvadratični čas (včasih izvedljivo)
O(n3) kubični čas (včasih izvedljivo)
O(2n) eksponenčni čas (redko izvedljivo)

28. Primerjava časov rasti1
log n
3.3
4.3
4.9
5.3 n 10 20 30 40
n log n 33 86
147
213 n2
100
400
900
1,600 n3
1,000
8,000
27,000
64,000 2n
1,024
1.0 milijon
1.1 miliarda
1.1 trilijon

29. Grafična ponazoritev časov rasti10 20 30 40 60 80
100 50 n n2
n log n 2n n
log n

30. Primerjava v sekundah
Imejmo problem, v katerem moramo obdelati n podatkov.
Za reševanje problema imejmo na voljo več algoritmov. Predpostavimo, da na danem procesorju ti algoritmi potrebujejo za svojo izvedbo naslednje čase:
AlgoritemLog: 0.3 log2 n sec Algoritem Lin: 0.1 n sec Algoritem LogLin: 0.03 n log2 n sec Algoritem Quad: 0.01 n2 sec Algoritem Cub: n3 sec Algoritem Exp: n sec

31. Primerjava v sekundah (2)
Primerjamo, koliko podatkov (n) lahko obdela posamezen algoritem v 1, 2, …, 10 sekundah:
Log
Lin
LogLin
Quad
Cub
Exp 10 20 30 40 50 60 70 80 90
100
0:00 n
0:08
0:07
0:10
0:06
0:09
0:04
0:01
0:02
0:03
0:05

32. Računska kompleksnost
Primerja rast dveh funkcij
Neodvisnost od množenja s konstanto in od efektov nižjega reda
Metrika
Notacija “Veliki O” O()
Notacija “Veliki Omega” ()
Notacija “Veliki Theta” ()

33. Notacija "veliki O" (big O)
In mathematics, computer science, and related fields, big O notation describes the limiting behavior of a function when the argument tends towards a particular value or infinity, usually in terms of simpler functions. Big O notation allows its users to simplify functions in order to concentrate on their growth rates: different functions with the same growth rate may be represented using the same O notation.
Big O notation is also called Big Oh notation, Landau notation, Bachmann–Landau notation, and asymptotic notation. A description of a function in terms of big O notation usually only provides an upper bound on the growth rate of the function; associated with big O notation are several related notations, using the symbols o, Ω, ω, and Θ, to describe other kinds of bounds on asymptotic growth rates.

34. Notacija "veliki O"
Naj bo n nenegativno celo število, ki predstavlja velikost vhoda v nek algoritem
Naj bosta f(n) in g(n) dve pozitivni funkciji, ki predstavljata število osnovnih operacij (instrukcij), ki jih algoritem potrebuje za svojo izvedbo
cg(n)
f(n)
f(n) je sčasoma
navzgor omejena z
g(n) n0

35. Notacija veliki “Omega”
f(n) = (g(n))
iff  c, n0 > 0 s.t.  n ≥ n0 , 0 ≤ cg(n) ≤ f(n)
f(n)
cg(n)
f(n) je sčasoma
navzdol omejena z
g(n) n0

36. Notacija veliki “Theta”
f(n) = (g(n))
iff  c1, c2, n0 > 0 s.t. 0 ≤ c1g(n) ≤ f(n) ≤ c2g(n),  n >= n0
f(n)
c1g(n) n0
c2g(n)
f(n) ima dolgoročno
enako rast kot
g(n)

37. Analogija z realnimi števili
f(n) = O(g(n)) (a ≤ b)
f(n) = (g(n)) (a ≥ b)
f(n) = (g(n)) (a = b)
…Ta analogija ni povsem točna, vendar je tako razmišljanje o kmpleksnosti funkcije prikladno
Svarilo: “Skrite konstante” v teh notacijah imajo pri realnih številih praktično posledico.

38. Primeri 3n2 + 17 (1), (n), (n2)  spodnje meje
O(n2), O(n3), ...  zgornje meje
(n2)  točna meja

39. Notacija Veliki O (2)
f(n)=O(g(n)) če obstaja pozitivna konstanta C in nenegativno celo število n0 tako, da velja
f(n)  Cg(n) za vse nn0.
Pravimo, da je g(n) zgornja meja za f(n).
cg(n) = cn2
f(n) = n n0

40. Primeri F(n) = O(1) F(n) = O(log(n)) F(n) = 1 F(n) = 2
F(n) = c (konstanta)
F(n) = O(log(n))
F(n) = 2log(n)
F(n) = 3log2(4n5) + 1
F(n) = c1logc2(c3nc4) + O(log(n)) + O(1)

41. Primeri (2) F(n) = O(n) F(n) = O(nlog(n)) F(n) = 2log(n) F(n) = n
F(n) = c1n + O(n) + O(log(n))
F(n) = O(nlog(n))
F(n) = 3n + 2
F(n) = nlog(n)
F(n) = 3nlog4(5n7) + 2n
F(n) = c1nlogc2(c3nc4) + O(nlog(n)) + O(n)

42. Primeri (3) F(n) = O(n2) F(n) = 3nlog(n) + 2n F(n) = n2
F(n) = 3n2 + 2n + 1
F(n) = c1n2 + O(n2) + O(nlog(n))

43. Povzetek o notaciji Veliki-O
O(1)  <  O(log n)  <  O(n)  <  O(n log n)  <  O(n2)  <  O(n3)  <  O(an)
Polynomial time is considered manageable. But algorithms that take exponential time are not very practical for larger n. Tower of Hanoi, for example, takes a few milliseconds for a small number of disks
(n = 10 or n = 20), but it takes forever (billions of years) for 64 disks.

44. Analiza kompleksnosti
Ocenimo n = velikost vhoda
Izoliramo vsako atomarno aktivnost (operacijo), ki jo moramo upoštevati
Najdimo f(n) = število atomarnih aktivnosti, izvedenih pri vhodu velikosti n
Kompleksnost algoritma = kompleksnost f(n)
Algorithm Complexity To apply the notation and theory of computational complexity to algorithms is a four step process. First discover a measure of size of input to the algorithm. Second, decide on a notion of atomic computational activity that captures the work of the algorithm. Third, find the function f(n) = the number of atomic computations performed on input of size n. Finally, the complexity of the algorithm is the complexity of f(n). We illustrate this process in several examples as we conclude this chapter, as well as in various places throughout the remainder of the course.

45. Časovna kompleksnost zanke
for (j = 0; j < n; ++j) {
// 3 atomarne operacije }
Kompleksnost = (3n) = (n)
Algorithm Complexity - Loops Despite the facetious remarks we made earlier about how "obvious" it is that a simple fixed-bound loop terminates, it actually is true that simple loops are straightforward to analyze. Usually it is clear when and why they terminate and what computational work is accomplished in each iteration of the loop body. If, for example we define an atomic computation as a call to a comparison operator, there might be three such calls in the loop body. That situation is depicted in the slide. The complexity of the loop is defined to be the complexity of the function
   f(n)
= (no. of atomics in loop body) x (no. of iterations of loop)
= (3) x (n)
= 3n
Thus, the complexity of this loop is equal to
   Θ(f(n))
= Θ(3n)
= Θ(n)
The situation is often not quite this simple, however.

46. Zanke s stavkom break for (j = 0; j < n; ++j) {
// 3 atomarne operacije
if (pogoj) break; }
Zgornja meja= O(4n) = O(n)
Spodnja meja= (4) = (1)
Kompleksnost= O(n)
Algorithm Complexity - Loops with Break The case of a loop with a conditional breakout is shown in this slide. In the cases where the loop runs to normal termination, the run time of the loop is correctly modelled by the same function as for the simple loop above. But in other cases, the loop may terminate sooner. These cases are data dependent; that is, the runtime of the loop varies from an upper bound of 3n = O(n) to a lower bound of 3 = Ω(1), depending on the specific input to the loop. We cannot conclude that the algorithm has complexity Θ(n) because the lower bound condition >= Ω(n) does not hold. Therefore, the best we can conclude is that the loop has complexity <= O(n).

47. Zaporedje zank for (j = 0; j < n; ++j) { // 3 atomarne operacije }
Kompleksnost = (3n + 5n) = (n)
Algorithm Complexity - Loops in Sequence This slide shows two loops one following the other in the source code. These are sometimes referred to as concatenated loops. Concatenated program blocks execute in sequence, one after another. Therefore the runtime of two concatenated blocks is the sum of the runtimes of the individual blocks. For the situation depicted on the slide, the runtime is bounded above by O(3n + 5n) <= O(n).

48. Vgnezdene zanke for (j = 0; j < n; ++j) { // 2 atomarni operaciji
for (k = 0; k < n; ++k) {
// 3 atomarne operacije }
Algorithm Complexity - Loops Nested This slide shows two loops one inside the other in the source code. These are sometimes referred to as composed loops. The runtime of two composed blocks is the product of the runtimes of the individual blocks. Thus, the runtime of the composed loops depicted in the slide is bounded above by O((2 + 3n)n) <= O(2n + 3n2)) <= O(n2).
Kompleksnost = ((2 + 3n)n) = (n2)

49. Zaporedni stavki Komleksnost = O(2n) + O((2+3n)n) = O(n) + O(n2)
for (i = 0; i < n; ++i) {
// 1 operacija
if(condition) break; }
for (j = 0; j < n; ++j) {
// operacija
for (k = 0; k < n; ++k) {
// 3 operacije

50. If-then-else Kompleksnost = = O(1) + max ( O(1), O(N)) = O(1) + O(N)
if(condition)
i = 0;
else
for(j = 0; j < n; j++)
a[j] = j;

51. Zaporedno iskanje
Imamo neurejen vektor a[ ], iščemo, če v njem nastopa X
for (i = 0; i < n; i++) {
if (a[i] == X) return true; }
return false;
Algorithm Complexity - Sequential Search This slide shows the usual (more efficient) version of sequential search in which there is early breakout of the loop immediately upon successful search. This is modelled by the simple loop with break, and hence has complexity <= O(n).
Velikost vhoda: n = a.size()
Kompleksnost = O(n)

52. Binarno iskanje = O(log(n))
Imamo urejen vektor a[].V njem iščemo lokacijo elementa X
unsigned int binary_search(vector<int> a, int X) {
unsigned int low = 0, high = a.size()-1;
while (low <= high) {
int mid = (low + high) / 2;
if (a[mid] < X)
low = mid + 1;
else if( a[mid] > X )
high = mid - 1;
else
return mid; }
return NOT_FOUND;
Algorithm Complexity - Binary Search This algorithm consists of a single loop that does not have any abnormal breakout termination, so the complexity of the loop is essentially the number of loop iterations as a function of n = size of input. Some helpful observations (derived from our previous analysis of correctness) follow.
Observation 1. The loop terminates after the search range is reduced to size <= 1.
Observation 2. The search range is n = size for the first iteration of the loop.
Observation 3. The search range is reduced by 1/2 at each iteration.
Thus, the loop runs for as many times as we can divide n by 2 before reaching the value 1. The first k sizes in these iterations are n, n/2, n/4, n/8, ..., n/2k-1, and the loop termination condition is
    n/2k-1 == 1     equivalent to     n == 2k-1     equivalent to     log2n == k-1.
The last inequality shows that the loop terminates in log2n iterations (give or take one). The complexity of binary search is therefore (log2n). An exercise for this chapter is to verify the three observations.
Velikost vhoda: n = a.size()
Kompleksnost: O( k iteracij x (1 primerjava + 1 prirejanje) v zanki)
= O(log(n))

53. Štetje iteracij pri binarnem iskanju
unsigned int binary_search(vector<int> a, int X) {
unsigned int low = 0, high = a.size()-1;
while (low <= high) {
int mid = (low + high)/2;
if (a[mid] < X)
low = mid + 1;
else if( a[mid] > X )
high = mid - 1;
else
return mid; }
return NOT_FOUND;
Št.iteracij prostor iskanja
1 n
2 n/2
3 n/4
k n/2(k-1)

54. Štetje iteracij pri binarnem iskanju (2)
unsigned int binary_search(vector<int> a, int X) {
unsigned int low = 0, high = a.size()-1;
while (low <= high) {
int mid = (low + high)/2;
if (a[mid] < X)
low = mid + 1;
else if( a[mid] > X )
high = mid - 1;
else
return mid; }
return NOT_FOUND;
n/2(k-1) = 1
n = 2(k-1)
log2(n) = k - 1
log2(n) + 1 = k
Funkcija kompleksnosti f(n) = log(n) iteracij x 1 primerjanje/zanko = (log(n))

55. Rekurzija To je v resnici navadna zanka, zakrinkana v rekurzijo
kompleksnost = O(n)
long factorial( int n ) {
if( n <= 1 )
return 1;
else
return n * factorial( n - 1 ); }
long fib( int n )
if ( n <= 1)
return fib( n – 1 ) + fib( n – 2 );
Fibonaccijevo zaporedje:
kompleksnost= O( (3/2)N )
torej eksponencialno !!

56. kompleksnost iskanja maksimuma?
double M=x[0];
for i=1 to n-1 do
if (x[i] > M)
M=x[i];
endif
endfor
return M;
T(n) = a+(n-1)(b+a) = O(n)
Pri tem je “a” čas enega prirejanja in “b” je čas ene primerjave
Tako “a” kot “b” sta konstanti, odvisni od aparaturne opreme
Opazimo, da nam veliki O prihrani
Relativno nepomembne aritmetične podrobnosti
Odvisnost od aparaturne opreme

57. Euklidov algoritem Poišči največji skupni delitelj med m in n
ob predpostavki m ≥ n
Kompleksnost = O(log(N))

58. Potenciranje Izračunaj xn Primeri: Kompleksnost= O( logN )
x11 = x5 * x5 * x
x5 = x2 * x2 * x
x2 = x * x
Kompleksnost= O( logN )
Zakaj tega nismo računali z rekurzijo na naslednji način?
pow(x,n/2)*pow(x,n/2)*x

59. Notacija "Veliki O" v praksi
Pri računanju kompleksnosti,
f(n) je dejanska funkcija
g(n) je poenostavljena verzija funkcije
Ker pogosto gledamo časovno kompleksnost f(n), uporabljamo namesto f(n) zapis T(n)

60. Načini poenostavljanja
Če je T(n) vsota konstantnega števila izrazov, izpustimo vse izraze razen najbolj dominantnega (največjega)
Izpustimo vse množilnike tega izraza
Kar ostane, je poenostavljena g(n).
Primeri:
amnm + am-1nm a1n+ a0=O(nm).
n2-n+log n = O(n2)

61. Značilnosti notacije veliki O
Notacija "veliki O" je mehanizem poenostavitve ocene časa oziroma pomnilniškega prostora.
Izgubili smo na natančnosti, pridobili na enostavnosti ocene
Obdržali smo dovolj informacije o občutku za hitrost (ceno) algoritma in za primerjavo konkurenčnih algoritmov.

62. Primeri formul 1+2+3+…+n= n(n+1)/2 = O(n2).
…+n2= n(n+1)(2n+1)/6 = O(n3)
1+x+x2+x3+…+xn=(x n+1 – 1)/(x-1) = O(xn).

63. Primer: Hanojski stolpiči(1)
Na podstavku imamo tri navpične paličice.
Na palici 1 imamo stolpič iz več ploščic različne velikosti. Največja ploščica je na dnu, najmanjša na vrhu stolpiča.
Naenkrat lahko premaknemo eno ploščico iz katerekoli palice na katerokoli palico. Nikdar ne smemo postaviti večje ploščice na manjšo.
Problem: premik stolpiča ploščic iz palice 1 na palico 2.
Animacija (z dvema ploščicama): 1 2 3 1 2 3 1 2 3 1 2 3

64. Primer: Hanojski stolpiči(2)
Algoritem Hanojskih stolpičev:
To move a tower of n disks from pole source to pole dest:
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.

65. Primer: Hanojski stolpiči(3)
Animacija (s 6 ploščicami):
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.
source
dest
spare
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.
source
dest
spare
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.
source
dest
spare
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.
source
dest
spare
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.
source
dest
1. If n = 1: Move a single disk from source to dest. 2. If n > 1: Let spare be the remaining pole, other than source and dest Move a tower of (n–1) disks from source to spare Move a single disk from source to dest Move a tower of (n–1) disks from spare to dest. 3. Terminate.
source
dest
spare

66. Primer: Hanojski stolpiči(4)
Analiza (štetje premikov):
Naj bo moves(n) število premikov, potrebnih za premik stolpiča z n ploščicami. Tedaj:
moves(n) = 1 if n = 1 moves(n) = moves(n–1) if n > 1
Rešitev:
moves(n) = 2n – 1
Časovna kompleksnost je O(2n).
WEB
DEMO