Literatura:

-Mari-Janii;
-Prezentacije (moodle);
-Milo Tomaevi : Algoritmi i strukture podataka;
-Internet;
Plan aktivnosti u semestru:
Od 1.do 8.sedmice P/A/L, u 9.sedmici 1.kolokvijum. Od 10.do 14.sedmice P/A/L, a u
15.sedmici 2.kolokvijum (6.juni).
Ocjenjivanje:
-Laboratorija:
-Kolokvijum I:
-Kolokvijum II:
-Zavrsni ispit:

0-15 bodova;
0-20 bodova (mora biti preko 40%);
0-25 bodova (mora biti preko 40%);
0-40 bodova (mora biti preko 50%);

Predavanje I:
Rekurzija:
Rekurzivna funkcija je funkcija koja poziva samu sebe. 2 su osnovna elementa svake
rekurzije:
1) Bazni ili osnovni sluaj (moe imati vise osnovnih sluaja)(zaustavljanje
funkcije);
2) Rekurzivni korak (nain na koji se funkcija iznova poziva, tako to onaj
sloeniji problem svodi na rjeavanje jednostavnijeg);
Primjer:
x^n={1, n=0 (bazni ili osnovni sluaj);
Primjer, rekurzivna definicija faktorijela:
n!=1*2**n (nerekurzivno ili iterativno)
n!={1, n<=1; n*(n-1)!, n>1
Primjer, rekurentna formula:
Xn=2*Xn-1+3*Xn-2, i bitno je koliko je X0 i X1
Implementacija u C:
Iz primjera x^n:
double stepenovanje(double x, int n)
{
if (n==0)
return 1;
else

n>0, x*x^(n-1) (rekurzivni korak);

return x*stepenovanje(x,n-1);
}
Program:
#include <stdio.h>
double stepenovanje(double x, int n)
{
if (n==0)
return 1;
else
return x*stepenovanje(x,n-1);
}
int main ()
{
printf(2^3= %.2lf\n, stepenovanje(2,3));
return 0;
}
Nain rada prethodno napisane funkcije:
stepenovanje (2,3)
x=2
n=3 > 0 => return 2*stepenovanje(2,2);
Zatim
x=2
n=2 > 0 => return 2*stepenovanje(2,1);
Zatim
x=2
n=1 > 0 => return 2*stepenovanje(2,0);
Zatim
x=2
n=0 => return 1 ;
Proces rada je da se return zadnji vraa prethodnom, redom 2*1, zatim 2*2*1, zatim 2*2*2*1
i to je rezultat.
Proces izvravanja rekurzije:
Sve sto vai za funkcije vai i za rekurzivne. Izvrsni kod je u segment kodu.
Iz prethodnog primjera:
stepenovanje (2,3)
Odozgoo raste stek
Na steku se ostavlja 2 i 3(koja je konvencija pozivanja, zavisi redoslijed njihovog stavljanja
na stek.
Na stek se prvo stavlja 3, odnosno n. Zatim se na stek stavlja 2, odnosno x. Zatim se stavlja
adresa povratka u main() Ovo do sada je kada se udje u funkciju stepenovanje. Ovaj dio
do sada napisan je stek okvir prve funkcije za stepenovanje.

Zatim ide poziv funkcije stepenovanje (2,2). Ide n, zatim x, zatim adresa povratka u
stepenovanje. Ovo je stek okvir 2.stepenovanje funkcije.
I tako dalje. Vracanje poslednje funkcije u prethodnu ona se skida sa steka.
Zatim poslednja funkcija vraca rezultat u main() i brise se.
Heap, dinamika memorija
Data segment stringovi, statike promjenjive
Main() stepenovanje (njihov kod), segment koda Adrese odozdo rastu
1) Zato rekurzija mora da konvergira?
Mora da ide prema jednostavnom sluaju. Ona na stek ostavlja svaki poziv funkcije,
sve dok se ne potroi, odnosno dok ima steka, za razliku od beskonane petlje koja ne
troi memoriju, samo procesorsko vrijeme (for (;;);). Znai pro
2) Zato mora da postoji sliaj za zaustavljanje rekurzije?
Mora da prekine da bi se omoguilo novo zauzimanje steka.
Dobre i loe strane rekurzije:
Kod je kratak, lako se ita, svodi se program na jednostavnije, lako se odrava i lako se
ispravlja. Loe strane su cijena poziva (svaki novi poziv nove funkcije je troenje memorije
steka i usporavanje (ako na stek treba da iskopirate argumente... mi smo time potrosili
vrijeme, nekoliko memorijskih ciklusa). Dolazi do poveanja vremenske i prostorne
sloenosti. Jo jedna strana loa, a to su suvina izraunavanja ili izvravanja. Moe se desiti
da kroz izvrsavanje desi da ste vec neto izvravali.
Primjer suvinog izvravanja, Fibonaijev niz: 1 1 2 3 5 8 13 21 34...
f(n)={1, n<=2; f(n-1)+f(n-2), n>2
Implementacija prethodne rekurzije:
int fibonaci(int n)
{
if (n<=2) return 1;
else
return fibonaci(n-1)+fibonaci(n-2);
}
Ako hoemo da nadjemo 4.clan:
fibonaci(2)+fibonaci(3)
n=2 => return 1; n=3 => fibonaci(1)+fibonaci(2)
n=1 => return 1; n=2 => return 1;
Tehnike za eliminaciju suvinih izvravanja:
1) Memoizacija je tehnika kojom se u odgovarajucoj strukturi podataka pamte
vrijednosti za razliite elemente. Odnosno ona za odgovarajue vrijednosti
argumenata provjerava da li ima izraunato ve. Ako postoji, vraa taj rezultat, ako
ne, rauna.
Modifikacija Fibonaijevog niza sa memoizacijom:

int fibonaci(int n)
{
static int memo[MAX]={0,1,1};
if (memo[n]!=0) return memo[n];
else
return memo[n]=fibonaci(n-1)+fibonaci(n-2);
}
Hanojske kule:
prebaci(n, sa, na, peko);
void prebaci(int n, char SA, char NA, char PREKO)
{
if (n==1)
printf(%c -> %c\n, SA, NA);
else
{
prebaci(n-1,SA , PREKO, NA);
printf(%c -> %c\n, SA, NA);
prebaci(n-1, PREKO, NA, SA);
}
}

Predavanja II
Eliminacija rekurzije:
Repna rekurzija: situacija kada rezultat koji se dobije iz nekog rek. poziva, a da nakon njega
nema dodanih operacija vezanih za njega.
double stepenovanje (double x, int n)
{
if (n == 0)
return 1;
else
return x*stepenovanje(x, n-1);
} //Ovakva rekurzija nije repna, npr.
void f(tip arg) // neka rekurzivna funkcija
{
pocetak:
if (uslov_za_osnovni_slucaj)
osnovni_slucaj;
else
f(novi_arg); ID= >{ arg=novi_arg; goto pocetak;}
}//repna rekurzija

Pozivne konvencije (eng. calling convention):

Vrenje poziva funkcije. Skup svih pravila koje se tiu funkcija je ta konvencija.
Pozivne konvencije ukljuuju:
1) nain prenosa argumenata (gdje (gdje se nalaze arg koji se prenose u funkciju.
Obino: stack, registri procesora, esto stack-registri) , kojim redom (RTL i LTR
(right to left, left to right));
2) nain vraanja rezultata: EAX (registar koji se zove akumulator, extended acumulator,
u njega se vraca rezultat, ako moe, ako ne moe vraa se adresa), postoji i EDX
(64bit = 32bit * 2);
3) odgovornost pozivaoca/pozivanog za ienja steka i pamenje sadraja registara (ako
na stek idu argumenti, neko mora da ih skine odatle (rije je o argumente funkcije)
(CALLER CLEAN-UP (za C) && CALLEE CLEAN-UP);
4) cdecl (c-declaration) (prenos arg preko steka, RTL je, EAX, caller clean-up);
Prestavnik tipian za LTR je Pascal.
Funkcije sa promjenljivim brojem argumenata:
#include <stdio.h>
int main()
{
printf(Zdravo\n);
printf(Danas je %02d.%02d.%4d\n, 4, 3 ,2015);
return 0;
}
Funkcija printf:
int printf(const char *format, ); // vraa broj znakova ispisa
const znai da ga funkcija nee promjeniti.
Funkcija koja ima , to znai da funkcija ima promjenljiv argumenata.
int scanf(const char *format, ...) //vraa broj uitanih podataka
tip f (obavezan-argument (u kojem se vidi koliko ima argumenata), );
Definisani makroi koji omogucavaju bezbjedno dohvatanje neobaveznih argumenata u
funkciji sa neobaveznim brojem argumenata: <stdarg.h>.
Prvi od njih je va_list, svojevrstan pokazivacki tip, koji cemo koristiti za pristup.
Drugi va_start (Makroo koji omoguava inicijalizaciju na start)
Trei va_arg (sekvencijalno dohvatanje argumenataa, jedan po jedan)
etvrti makroo va_end (kraj dohvatanja).
Primjer:

#include <stdio.h>
#include <stdarg.h>
int zbir (int n, )
{
int i, s=0;
va_list args;
va_start (args, n);//va_start(args, ime posljednjeg obaveznog arg)
for ( i = 0; i <= n; i++)
s += va_arg (args, int);
va_end(args);
return s;
}
int main()
{
printf(Zbir (10,20) =%d\n, zbir(2,10,20);
printf(zbir(10,20,30=%d\n, zbir(3,10,20,30);
return 0;
}
STEK raste prema
dole
20
10 =

va_star
t (args,n)
2=n

Return adress u
main (vraanje
adrese povratka)
Kada zavri , sve se
brie.

Pokazivai na funkcije:
Do sada smo imali void *malloc (size_t n);
Deklaracija:
tip (*) (deklaracija argumenata ID= lista tipova)

DATOTEKE

-kolekcija podataka smjetenih na sekundarnoj memoriji.

-znaaj je ogroman, itav sistem je smjeten u fajlovima.
Klasifikacija datoteka:
-prema nainu smjestanja (reprezentaciji) podataka (tekstualne, binarne).
-prema nainu organizacije/pristupa podacima u datoteci (sekvencijalne(programski c
podrzava ovu organizaciju), direktne (random, to su tipino zapisi fixne duine, i zna se tano
na kojem bajtu poinje novi zapis, ne moraju redom da se itaju podaci), i indeksne
(indeksno-sekvencijalne, tipino to zapravo znai da se podaci dre u jednom
fajlu(sekvencijalnom), indexni jedan fajl(postojanje kljua koji slui za sortiranje, postoji i
pointer koji kae gdje se nalazi zapis u sekvencijalnoj datoteci).
-Tekstualna datoteka (to su one iji je sadraj itljiv(razumljiv, da ga moe u nekom editoru
teksta proitati). Svaki znak je ascii kod ustvari. Svaki taj string zavrava terminatorom EOL
(zavisno od operativnog sistema, 1 ili 2 znaka, npr u windowsu (CR-LF), u nekim drugima je
samo CR ili samo LF).
Tekstualne datoteke su niz linija teksta (stringova).
Primjeri tekstualnih datoteka:
1) datoteke sa izvornim kodom (npr .c)
2) esto neke konfiguracione datoteke (HTML, XML)
-Binarne datoteke: To je datoteka u kojoj je reprezentovan sadraj binarno, NIJE ASCII
CODE!
Primjer:
int i = 10;
BINARNA DATOTEKA
TEKSTUALNA TATOTEKA
00000000A (4 bajta)
10 (2 bajta)
Datoteke u programskom jeziku C:
-postoji podrka i za tekstualne i za binarne datoteke.
-po nainu organizacije datoteke u C su sekvencijalne.
-postoji mogunost direktnog pristupa.
-datoteke u jeziku C je ustvari dugaki niz bajtova ili tok (eng. stream).
-komunikacija sa svim eksternim ureajima (periferijama) reprezentuje se ili posmatra se kao
tok.
-sve funkcije za manipulaciju tokovima <stdio.h>. Tu je definisan tip FILE. Struktura file
sadri atribute koji opisuje datoteku koja je otvorena. Tu postoji i indeks toka, ima i indikator
kraja datoteke (toka), ima indikator greke
FILE *fp; // (ovo moramo da imamo, ako hoemo da koristimo datoteku)
FILE *fp1, *fp2;

Osnovne operacije nad datotekama:

1) otvaranje datoteke,
2) pristup datoteci (itanje iz datoteke, upisivanje u datoteku i pozicioniranje),
3) provjera statusa (provjera statusa pokazivaa, da li je kraj, da li je greka, koja je
pozicija pokazivaa),
4) zatvaranje datoteke;
Otvaranje datoteke:
Koristi se funkcija FILE *fopen (char *ime, char *mode), (vraa pointer na FILE).
*mode je reim rada. Osnovni reim rada/otvaranaj su: r (itanje iz fajla), w (pisanje u
fajl), a (append, ako fajl postoji bie otvoren, i pokaziva e biti na mjestu poslije svega u
datoteci). Postoje i kombinovani reimi r+ (ima mogunost itanja, ali moe i pisanje),
w+ (podrazumjeva se itanje, ali moe i pisanje), a+ (dopisivanje, a moe i itanje (s
poetka)).
Rad sa binarnim datotekama: SVE VAI ISTO KAO I ZA TEKSTUALNO, samo se doda b
na kraj mode.
FILE *fp;
fp = fopen(ime, rb); //otvaranje datoteke (binarne) u reimu za itanje
Tipino za otvaranje:
if (fp = fopen(ime, rb)) != NULL)
{
//uspjesno otvaranje
}
else
printf(Fajl ne moze da se otvori);
itanje i pisanje iz/u tekstualnih datoteka
itati i pisati se moe po jedan znak ili niz znakova.
itanje jednog znaka: int fgetc (FILE *dat).
itanje stringa: char fgets(char *s, int n (maksimalan broj znakova u tom stringu, uklj. nulu
ili e se itati do kraja linije),FILE *dat);
Ima mogunost i formatiranog itanja: int fscanf(FILE *dat, const char *format, );
Upis u datoteku:
Posoji mogunost upisivanja jednog ili vie znakova.
Upis jednog znaka: int fputc (int znak, FILE *dat);
Upis stringa: int fputs(char *s, FILE *dat);
Ima formatiran upis: int fprintf(FILE *dat, const char *format, ...);
Zatvaranje datoteke: int fclose(FILE *dat);
Primjer:
#include <stdio.h>
int main()
{
FILE *fp;
if (fp == fopen(text.txt, w));
{
for (int i = 0; i < 20; i++)
fputc(A+i, fp);
fclose(fp);

if (fp = fopen(text.txt, r))

{
printf(Sadrzaj datoteke:\n);
char znak;
while (znak = fgetc(fp) != EOF)
printf(%c, znak);
fclose(fp);
}
return 0;
}

for (int j = 1; j<=10; j++)

fprintf(fp,, %d , i); // Upis je 1 2 3 4 5 6 7 8 9 10
while (fscanf(fp, %d, &x))
printf(%d, x);
while (fscanf(fp,%f, &x))
printf(%5.2f, x);
Binarne datoteke:
itanje i pisanje moe i bajt po bajt. Sve je isto, ali kod njih ima blokovsko pisanje i
blokovsko itanje.
Blokovsko itanje/pisanje (samo za binarne). Za itanje se koristi funkcija int fread(void *niz,
int velicina, int n, FILE *dat). Za upisivanje int fwrite(void *niz, int velicina, int n, FILE
*dat).
Primjer:
#include <stdio.h>
typedef struct t { float a, b, c;} TROUGAO;
int main()
{
FILE *fp;
TROUGAO t, niz[3] = {{2, 3, 4}, {3, 4, 5}, {6, 7, 8}};
if (fp = fopen(TROUGAO.DAT, w))
{
if (fwrite(niz, sizeof(TROUGAO), 3, fp) < 3)
printf(GRESKA);
fclose(fp);
if (fp = fopen (trougao.dat, r))
{
while(fread(&t, sizeof(TROUGAO), 1, fp)
printf(a = %5.2f b = %5.2f c = %5.2f\n, t.a, t.b, t.c);
fclose (fp);
}
}
return 0;
}
Operacije pozicioniranja u datoteci:

Funkcija int fseek(FILE *dat, int pomjeraj, int reper);

reper moe biti seek_set (oznaava poetak datoteke ili prosto nula), seek_cur (trenutna
pozicija ili prosto 1), seek_end (kraj datoteke ili prosto 2);
fseek(fp, 0, 0) nula bajtova u odnosu na poetak
fseek(fp, -1, 2) posljednji znak u datoteci
Trenutna pozicija dobija se pomou int ftell(FILE *dat).
Premotavanje na poetak: void rewind(FILE *dat).
Funkcije za provjeru statusa:
Provjera kraja datoteke int feof(FILE *dat).
Tipina upotreba:
while (!feof(dat)).
Provjera da li ima neka greaka int ferror, clearrer(brie greke);

SORTIRANJE:

-preureivanje rasporeda elemenata kolekcije u skladu sa nekim kriterijumom (dovoenje

elemenata kolekcije u odgovarajui poredak.
Poredak moe biti: rastui (ascending)(strogo rastui i monotono rastui), opadajui
(descending)(strogo opadajui i strogo rastui).
Klasifikacija tehnika za sortiranje:
1) prema mjestu sortiranja
a. spoljanje (kolekcija je u sekundarnoj memoriji (datoteke)),
b. unutranje (kolekcije koje se u potpunosti nalaze u operativnoj memoriji
(nizovi, liste));
2) Prema nainu manipulacije elemenata kolekcije
a. direktno (direktno nad podacima koji se nalaze u kolekciji, kada (ako je nesto
sto se sortira maleno)),
b. indirektno (pa npr adresno sortiranje);
Algoritmi za sortiranje zasnovani na poreenju elemenata:
1) selekcija (Selection-sort (svaki put biramo zeljeni iz nesortiranog dijela i dodajemo
ga na kraj sortiranog)),
2) ubacivanje: (Insertion-sort, Shell-sort (postoji sortirani i nesortirani dio kolekcije,
uzme sledeci u nesortiranom dijelu i ubaci u odgovarajuce mjesto sortiranog dijela)),
3) spajanje (Merge-sort (postoje sortirane kolekcije koje se spajaju),
4) zamjene (Bublle-sort, Quick-sort);
Selection- sort:
Prolazi od poetka do kraja kroz neureeni dio kolekcije i izabere se najbolji i doda se na
ureeni dio selekcije.
Primjer:
64178532
1.prolaz kroz kolekciju traimo najmanjeg u neuredjenom dijelu:
14678532
2.prolaz:
12678534
itd...
12345678
Source code:
void SelectSort(<tip> niz[], int n)
{
int I, rb, j;
for ( i = 0; I < n-1; I ++)
for ( rb = 0, j = I ; j < n ;j ++)
{
if (niz[j] < niz[rb]) rb = j;
}
if ( rb!=i)
{

<tip> pom = niz[i];

niz [i] = niz[rb];
niz[rb] = pom;
}
}
Analiza sloenosti:
Velika for petlja ide n+1 put, a manja ide n-i operacija. T(n) = Suma(i=0 n-2, n-i) = n + n -1
+ n 2 + ... + 2 = (n 1)*n (1 + 2 + + n 2) = n*(n-1) (n-2)*(n-1)/2 = (n^2 +n 2)/2
Priblino n^2/2 + n/2; (kae se da ima kvadratno vrijeme);
Pie se T(n) = O(n^2); ALGORITAM KVADRATNE SLOENOSTI!
Insertion-sort:
Prvi iz neureenog dijela se ubacuje na odgovarajue mjesto ureenog dijela.
Primjer:
6 4 1 7 8 5 3 2 polazna kolekcija, prvi element je ureen odmah.
Prvi prolaz (pomjeram 4 ulijevo dok treba) :
46178532
Drugi prolaz:
14678532
itd ...
12345678
void InsertSort(<tip> niz[], int n)
{
int I;
for (I = 1; I < n; I ++)
{
<tip> pom = niz [i];
int j;
for (j = I; j > 0 && pom < niz[j 1]; j --)
{
niz[j] = niz[j-1];
niz[j-1] = pom;
}
}
}
Analiza sloenosti:
n-1 prolaz velike petlje. Za manju petlju zavisi koliko je ona ureena.
U najboljem sluaju je O(n) (algoritam linearne sloenosti). Najgori sluaj mala petlja vri i
koraka.
T(n) = suma(i=1 do n-1, i) = n^2/2 n /2 ;

Shell-sort

Gleda ekvidistantne elemente, poredi, i mjenja ako ima potrebe. Zatim taj interval polovi
Primjer:
h=n/2=4
64178532
Prvi prolaz:
64178532
Drugi prolaz:
64178532
Trei prolaz:
64178532
etvrti prolaz:
64128537
h = h / 2 = 2;
Imamo:
64128537
Prvi prolaz:
14628537
Drugi prolaz:
12648537
Trei prolaz:
12648537
etvrti prolaz:
12648537
Peti prolaz:
12643587
esti prolaz:
12643587
h = h / 2 = 1;
Imamo:
12643587
Prvi prolaz:
12643587
Drugi prolaz:
...
12345678
Source code:
void ShellSort(<tip> niz[], int n)
{
int I, j, h;
for (h = n / 2; h >0; h/=2)
{
int j;
for (I = h; i < n; i ++)
{
<tip> pom = niz[i];
for ( j = I; j>=h && pom < niz[j-h]; j -=h;
niz[j] = niz[j h];
niz[j] = pom;
}}}
Analiza sloenosti:

T(n) = O (n^2)
najbolje.
Npr, u zavisnosti od izbora h:
Hibbard (1, 3, 7 2^k 1) O(n^(1.5))
Sechwick (1 5 19 41 119) O (n^1.33)
Merge-sort:
-rekurzivni algoritam (Devide and conquer);
Primjer:
6 4 1 7 8 5 3 2 polazna kolekcija
Dijeli na dvije kolekcije: 6 4 1 7 I 8 5 3 2
Zatim 6 4 I 1 7 I 8 5 I 3 2
Zatim ponaosob svaki.
Zatim se sparuju:
46 I 1 7 I 5 8 I 2 3
Zatim se sparuju:
1467I2358
Zatim:
12345678
void MergeSort (<tip> niz[], int begin, int end)
{
if (begin < end)
{
int sredina = (begin+end) / 2;
MergeSort(niz, begin, sredina);
MergeSort(niz, sredina + 1, end);
merge(niz, begin, sredina, end); //Spaja do sredine i od sredine
}
}
umjesto merge:
<tip> pom[end begin +1];
int I = begin, j = sredina + 1, k = 0;
while (I <= sredina && j <= end)
{
pom [k++] = (niz[i] < niz[j])?niz[i++] : niz[j++];
}
while (I <= sredina)
pom[k ++ ] = niz[I ++];
while (j <= end) pom[k++] = niz[j ++];
for (I = 0; I < len; I ++)
niz[begin + i] = pom [i];
Analiza sloenosti:
T(n) = O(n*log(n));
linearno-logaritamska sloenost;
Bublle-sort:
Primjer:

6417532
Prvi proglaz:
4617532
4167532
4167532
4165732
4165372
4165327
Drugi prolaz:
1465327
1465327
1456327
1453627
1453267
Trei prolaz:
1453267
1453267
1435267
1432567
etvrti prolaz:
1432567
1342567
1324567
Peti prolaz:
1324567
1234567
bubble select insert shell (poredak sloenosti);
Analiza sloenosti:
bubble O(n^2);
void BubbleSort (<tip> niz[], int n)
{
int I, j;
for ( I = 0; I < n 1; I ++ ) /* moglo bi se uslovno vidjeti da li je u medjuvremenu
sortirano*/
for ( j = I; j < n 1 - i; j++)
if (niz[j+1] < niz[j])
{
<tip> pom = niz[j];
niz[j] = niz[j+1];
nizp[j+1] = pom;
}
}

PRETRAIVANJE

-Pronalaenje (lociranje) eljenog elementa u kolekciji.

-s obzirom na to gdje se nalazi kolekcija:
1) unutranje (kolekcija je u operativnoj memoriji)
2) spoljanje (kolekcija je u sekundarnoj memoriji datoteka)
-Kolekcija moe biti ureena (sortirana) ili neureena (nesortirana);
Sekvencijalno pretraivanje (redom, jedan po jedan, esto se jo zove i redno/linearno);
Source code:
int seqSearch (<tip> niz[], int n, <tip> kljuc)
{
int I;
for (I = 0; I < n; I ++)
if (niz[I] == kljuc)
return I;
return -1;
}
T(n) = O(n)
Mogue ubrzanje: SORTIRANA KOLEKCIJA.
T(n) = O(n)
Source code:
int seqSearchSort (<tip> niz[], int n, <tip> kljuc)
{
int I;
for (I = 0; I < n && niz[i] < kljuc; I ++);
if (I == n) return -1;
if (niz[i] == kljuc) return I;
else
return -1;
}
Self-Organizing search (samoorganizujue pretraivanje)
- neureena kolekcija
- move to front nakon pronalaenja yapis/element ide na poetak
- move to back nakon pronalaenja element se premjesta na kraj, a svi
Source code:
int selfToFront (<tip> niz[], int n, <tip> kljuc)
{
int I;
for (I = 0; I < n; I ++)
if (niz[i] == kljuc)
{
<tip> pom = niz[i];
while (I > 0)
{ niz[i] = niz[i- 1]; I --;}

niz[i] = pom;
return 0;
}
return -1;
}
Binarno pretraivanje (pretraivanje polovljenjem intervala):
- Kolekcija je ureena
- polovimo interval, i traimo u kojem dalje da pretraujemo.