1. PODATKOVNE STRUKTURE IN ALGORITMI

2. Kaj je algoritem navodilo, kako opraviti določen postopek
KAJ storiti, KAKO to storiti
točna definicija odvisna od tega, komu je algoritem namenjen
Končno zaporedje ukazov, ki, če jih ubgamo, opravijo neko nalogo

3. Značilnosti algoritma
ima podatke
vrne rezultat
je natančno določen
se vedno konča
mogoče ga je opraviti

4. Vprašanja Kako zasnovati algoritem metode, strategije
Kako preveriti algoritem dokaz pravilnosti
Kako analizirati algoritem prostorska in časovna zahtevnost
Kako izraziti algoritem enoličnost, komu je namenjen, kaj so osnovna navodila, komentarji

5. Skupine algoritmov Deli in vladaj Požrešna metoda Sestopanje
Dinamično programiranje
Razveji in omeji

6. Skupine algoritmov Sortiranje Algoritmi nad grafi Numerični algoritmi
Iskalni algoritmi …

7. Podatkovne strukture v programskih jezikih zaloga vrednosti operacije
lastnosti operacij
neodvisnost od dejanske predstavitve KAJ je struktura in ne KAKO jo predstaviti

8. Opis strukture structure ime strukture begin declare opis funkcij
where
opis aksiomov
end

9. Pomembnejše strukture
sklad
vrsta
drevo
tabela
graf
...

10. Prostorska in časovna zahtevnost
količina sredstev, ki jih potrebujemo za rešitev problema
odvisnost od obsežnosti (velikosti) problema
kaj meriti
pogosto le ocenimo zahtevnost
red velikosti

11. Prostorska in časovna zahtevnost
najslabša možnost zgornja meja zahtevnosti
najboljša možnost spodnja meja zahtevnosti
pričakovana zahtevnost
meritve

12. Časovna zahtevnost O notacija O(n2), O(n log(n)), O(2n)
polinomski algoritmi (P)
razred NP nedeterministični algoritem v polinomskem času
P <> NP ???

13. Zakaj je časovna zahtevnost pomembna
Urejanje z mehurčki: (n2 - n)/2 primerjav
Vsaka primerjava: sekunde
10 stevil: 0.05 sek
100 stevil: 5 sek
1000 stevil: 500 sek
stevil (urejamo tel. imenik) sek = 1400 ur = slaba dva meseca

14. Primeri s := a[1]; for i := 2 to n do s := x*s + a[i];
podatki: ai, n, x
prostorska zahtevnost
časovna zahtevnost
po posameznih operacijah

15. časovna zahtevnost
prostorska zahtevnost

16. časovna zahtevnost dol := length(niz); je_pali := true; i := 1;
while (je_pali and (i < dol div 2)) do
begin
je_pali := (niz[dol-i+1] = niz[i]);
i := i + 1; }
časovna zahtevnost
najslabša
najboljša
pričakovana

17. Trije algoritmi za isti problem
Dano je zaporedje celih števil a1, a2, …, an. Naj bo Si,j = vsota ak, k = i, …, j
Poišči Sopt = maksimalna vsota
8, -6, 10, -14, 13, -5, 7, -9, 18, -3, 2 rešitev 13, -5, 7, -9, (24)

18. A- vse vsote! opt := 0; for i :=1 to n do { i - kje zacnem }
for j := i to n do begin { j - kje neham }
s := a[i];
for k := i + 1 to j do s := s + a[k];
if (s > opt) then opt := s;
end;

19. B - upoštevaj prejšnje vsote
Si,j = Si,j-1 + aj
opt := 0;
for i := 1 to n do begin
s := a[i];
if (s > opt) then opt := s;
for j := i + 1 to n do begin
s := s + a[j];
end

20. C - ali vzamemo zraven j-tega
Sj = Sj-1 + aj ali 0
opt := 0;
s := 0;
for i := 1 to n do begin { i - kje se konca! }
t := s + a[i];
if (t > 0) then
{ ce je vsota "se > 0, se i-tega
splaca vzeti }
s := t
else { drugace raje zacnemo na novo }
if (s > opt) then opt := s;
end;

21. Obsežnost nalog

22. Obsežnost nalog

23. Obsežnost nalog

24. Obsežnost nalog

25. Obsežnost nalog

26. Obsežnost nalog

27. Obsežnost nalog

28. Hitrost računalnika

29. Hitrost računalnika

30. Hitrost računalnika

31. Hitrost računalnika

32. Hitrost računalnika

33. Hitrost računalnika

36. Algoritmi za sortiranje

37. O sortiranju Kaj urejamo Kje so podatki Različne metode datoteke
notranji pomnilnik
Različne metode
če vemo za maksimalni podatek: urejanje s koši
vstavljanje, izbiranje, urejanje z mehurčki, urejanje s kopicami, hitro urejanje, zlivanje, ...

38. Časovna in prostorska zahtevnost
Kaj štejemo
Pogosto odločilni faktor primerjave:
števila
zapisi/strukture/objekti
slike
Včasih zahtevna zamenjava

39. Lastnosti dobrega algoritma za urejanje
pravilnost
hitrost
stabilnost - urejenih elementov ne zamenjuje
več ključev
naravnost - urejene elemente naj uredi hitro
morda predpriprava

40. 5, 2, 11, 7, 9, 36, 45, 1, 24

41. Urejanje z vstavljanjem
urejeni del / neurejeni del
: 7 * * * * * *
: 9 * * * * * …
vzemi naslednji element in ga vstavi na pravo mesto

42. Urejanje z vstavljanjem
na vrsti je a-ti elt.
pogledamo a-1 tega
če je ta manjši od njega, ta-1 prestavimo za eno mesto nazaj
pogledamo a-2 ega …
t := tabela[a];
b := a - 1;
while (b >= 1 and t < tabela[b]) do begin
tabela[b + 1] := tabela[b];
b := b - 1;
end;
tabela[b + 1] := t;
m m m _ v v v v

43. Urejanje z vstavljanjem
procedure vstavljanje(var tabela: tabl; koliko: integer) {
{ urejanje z vstavljanjem }
{ urejamo cela stevila }
var a, b, t: integer;
begin
for a := 2 to koliko do begin
t := tabela[a];
b := a - 1; { do kam so ze urejeni }
while (b >= 1 and t < tabela[b]) do begin { kam spada a-ti }
tabela[b + 1] := tabela[b];
b := b - 1;
end;
tabela[b + 1] := t;
end
vstavi.c

44. Lastnosti
pravilnost
naravnost
stabilnost
hitrost

45. Zahtevnost število primerjav najboljše najslabše: (n2+n)/2 - 1
urejeno zaporedje
n - 1x, na vsakem prehodu: 1 primerjanje
n - 1, Tb = O(n)
najslabše: (n2+n)/2 - 1
obratno urejeno
1 korak: 1 primerjava, 2 korak: 2, …, n-1 (zadnji): n-1
n(n-1)/2, Tw = O(n2)

46. O(n2) Zahtevnost število zamenjav povprečno najboljše: 2(n-1)
zahtevnejša analiza
vse možne razporeditve
(n2+n-2)/4
Ta = O(n2)
število zamenjav
najboljše: 2(n-1)
povprečno: (n2 + 9n - 10)/4
najslabše: (n2 + 3n - 4)/2
O(n2)

47. Prostorska zahtevnost
O(1) dodatnega prostora

48. Urejanje z izbiranjem poišči najmanjšega zamenjaj s prvim
od 2 do n poišči najmanjšega
zamenjaj z drugim
...

49. Poišči najmanjšega function poisci_najmanjsega
(tab: tabela; od_kje, do_kam: integer): integer;
(* poisce najmanjsega v tabeli tab od od_kje dalje *)
var
i_najm: integer; /* indeks trenutno najmanjsega */
i: integer;
begin
i_najm := od_kje;
for i := od_kje + 1 to do_kam do
if (tab[i] < tab[i_najm]) then i_najm := i;
poisci_najmanjsega := i_najm;
end;

50. Končni program procedure izbiranje(var tabela: tab; koliko: integer);
(* urejanje z izbiranjem *)
(* urejamo cela stevila *)
var a, : integer;
kje_najm: integer; (* indeks najmanjsega *)
for a := 1 to koliko - 1 do begin
kje_najm := poisci_najmanjsega(tabela,a,koliko);
(* zamenjamo *)
t := tabela[a];
tabela[a] := tabela[kje_najm];
tabela[kje_najm] := t;
end
end;

51. Lastnosti
pravilnost
naravnost
stabilnost
hitrost

52. Zahtevnost število primerjav vedno enako 1 korak: n - 1 2 korak: n - 2
n*(n-1)/2 primerjav

53. O(n2) Zahtevnost število zamenjav najboljše najslabše povprečno
urejeno zaporedje
n -1 elementov premaknemo: 3
3n - 3
najslabše
n2/4 + 3(n-1)
povprečno
n(ln n …)
O(n2)

54. Urejanje z mehurčki najlažji element splava na površje
plavanje - zamenjave

55. Urejanje z mehurčki
procedure mehurcki(var tabela: tab; koliko: integer);
(* urejanje z mehurcki *)
(* urejamo cela stevila *)
var a, b: integer;
t: integer;
begin
for a := 1 to koliko - 1 do
for b := koliko - 1 downto a do
if (tabela[b-1] > tabela[b]) then begin
(* zamenjamo *)
t := tabela[b-1];
tabela[b-1] := tabela[b];
tabela[b] := t;
end

56. Lastnosti
pravilnost
naravnost
stabilnost
hitrost

57. O(n2) Zahtevnost število primerjav vedno enako 1 korak: n - 1
n - 1 korak: 1
n*(n-1)/2 primerjav
O(n2)

58. O(n2) Zahtevnost število zamenjav najboljše najslabše povprečno
urejeno zaporedje
nobenega ne premaknemo: 0
najslabše
3(n2-n)/2
povprečno
3(n2-n)/4
O(n2)

59. Urejanje elementov

60. Hitro urejanje Izberi si delilni element razdeli na dva dela
<=x
>=x
z istim postopkom uredi oba dela

61. procedure qs_r(var t: tabela; l, d: integer) {
(* hitro uredi t od l do d *)
(* urejamo cela stevila *)
var
i, j, x: integer;
el: integer;
i := l; j := d; (* iskalca *)
x = t[l]; (* delilni element *)
while (i <= j) do begin
while (t[i]<x and i<d) do i := i + 1;
(* poisci prvega, ki ni manjsi *)
while (t[j]>x and j>l) do j := j - 1;
(* poisci prvega, ki ni vecji *)
if (i<=j) then begin (* zamenjaj *)
el := t[i];
t[i] := t[j];
t[j] := el;
i := i - 1; j := j - 1;
end;
if (l<j) qs_r(t,l,j); (* uredimo levo polovico *)
if (i<d) qs_r(t,i,d); (* uredimo desno polovico *)

62. Analiza zahtevno pričakovana zahtevnost: O(n log n)
na majhnih zaporedjih običajno nehamo in uporabimo kaj drugega
metoda lahko tudi O(n2) časa - če delilni element vedno največji
ena najbolj uporabljanih metod