Literatura: -Marić-Janičić;-Prezentacije (moodle);-Milo Tomašević : „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: 0-15 bodova;-Kolokvijum I: 0-20 bodova (mora biti preko 40%);-Kolokvijum II: 0-25 bodova (mora biti preko 40%);-Zavrsni ispit: 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 slučaj (može imati vise osnovnih slučaja)(zaustavljanje funkcije);

2) Rekurzivni korak (način na koji se funkcija iznova poziva, tako što onaj složeniji problem svodi na rješavanje jednostavnijeg);

Primjer:x^n={1, n=0 (bazni ili osnovni slučaj); n>0, x*x^(n-1) (rekurzivni korak);

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 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;

}

Način rada prethodno napisane funkcije:stepenovanje (2,3)x=2n=3 > 0 => return 2*stepenovanje(2,2);Zatimx=2n=2 > 0 => return 2*stepenovanje(2,1);Zatimx=2n=1 > 0 => return 2*stepenovanje(2,0);Zatimx=2n=0 => return 1 ;Proces rada je da se return zadnji vraća prethodnom, redom 2*1, zatim 2*2*1, zatim 2*2*2*1 i to je rezultat.

Proces izvršavanja rekurzije: Sve sto važi za funkcije važi i za rekurzivne. Izvrsni kod je u segment kodu. Iz prethodnog primjera:stepenovanje (2,3)Odozgoo raste stekNa 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, dinamička memorijaData segment stringovi, statičke promjenjiveMain() stepenovanje (njihov kod), segment koda Adrese odozdo rastu

1) Zašto rekurzija mora da konvergira?Mora da ide prema jednostavnom slučaju. Ona na stek ostavlja svaki poziv funkcije, sve dok se ne potroši, odnosno dok ima steka, za razliku od beskonačne petlje koja ne troši memoriju, samo procesorsko vrijeme (for (;;);). Znači pro

2) Zašto mora da postoji sličaj za zaustavljanje rekurzije?Mora da prekine da bi se omogućilo novo zauzimanje steka.

Dobre i loše strane rekurzije:Kod je kratak, lako se čita, svodi se program na jednostavnije, lako se održava i lako se ispravlja. Loše strane su cijena poziva (svaki novi poziv nove funkcije je trošenje memorije steka i usporavanje (ako na stek treba da iskopirate argumente... mi smo time potrosili vrijeme, nekoliko memorijskih ciklusa). Dolazi do povećanja vremenske i prostorne složenosti. Još jedna strana loša, a to su suvišna izračunavanja ili izvršavanja. Može se desiti da kroz izvrsavanje desi da ste vec nešto izvršavali.Primjer suvišnog izvršavanja, Fibonačijev 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 hoćemo 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 suvišnih izvršavanja:

1) Memoizacija je tehnika kojom se u odgovarajucoj strukturi podataka pamte vrijednosti za različite elemente. Odnosno ona za odgovarajuće vrijednosti argumenata provjerava da li ima izračunato već. Ako postoji, vraća taj rezultat, ako ne, računa.

Modifikacija Fibonačijevog 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;

elsereturn 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):

Vršenje poziva funkcije. Skup svih pravila koje se tiču funkcija je ta konvencija.Pozivne konvencije uključuju:

1) način prenosa argumenata (gdje (gdje se nalaze arg koji se prenose u funkciju. Obično: stack, registri procesora, često stack-registri) , kojim redom (RTL i LTR (right to left, left to right));

2) način vraćanja rezultata: EAX (registar koji se zove akumulator, extended acumulator, u njega se vraca rezultat, ako može, ako ne može vraća se adresa), postoji i EDX (64bit = 32bit * 2);

3) odgovornost pozivaoca/pozivanog za čišćenja steka i pamćenje sadržaja 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 tipičan 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, …); // vraća broj znakova ispisaconst znači da ga funkcija neće promjeniti.Funkcija koja ima …, to znači da funkcija ima promjenljiv argumenata.

int scanf(const char *format, ...) //vraća broj učitanih 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 omogućava inicijalizaciju na start)Treći 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_start (args,n)

2 = n

Return adress u main (vraćanje adrese

povratka)Kada završi , sve se

briše.

Pokazivači na funkcije:

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

DATOTEKE

-kolekcija podataka smještenih na sekundarnoj memoriji.-značaj je ogroman, čitav sistem je smješten u fajlovima.

Klasifikacija datoteka:-prema načinu smjestanja (reprezentaciji) podataka (tekstualne, binarne).-prema načinu organizacije/pristupa podacima u datoteci (sekvencijalne(programski c podrzava ovu organizaciju), direktne (random, to su tipično zapisi fixne dužine, i zna se tačno na kojem bajtu počinje novi zapis, ne moraju redom da se čitaju podaci), i indeksne (indeksno-sekvencijalne, tipično to zapravo znači da se podaci drže u jednom fajlu(sekvencijalnom), indexni jedan fajl(postojanje ključa koji služi za sortiranje, postoji i pointer koji kaže gdje se nalazi zapis u sekvencijalnoj datoteci).

-Tekstualna datoteka (to su one čiji je sadržaj čitljiv(razumljiv, da ga može u nekom editoru teksta pročitati). Svaki znak je ascii kod ustvari. Svaki taj string završava 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 sadržaj binarno, NIJE ASCII CODE! Primjer:int i = 10;BINARNA DATOTEKA TEKSTUALNA TATOTEKA00000000A (4 bajta) 10 (2 bajta)

Datoteke u programskom jeziku C:-postoji podrška i za tekstualne i za binarne datoteke.-po načinu organizacije datoteke u C su sekvencijalne.-postoji mogućnost direktnog pristupa.-datoteke u jeziku C je ustvari dugački niz bajtova ili tok (eng. stream).-komunikacija sa svim eksternim uređajima (periferijama) reprezentuje se ili posmatra se kao tok.-sve funkcije za manipulaciju tokovima <stdio.h>. Tu je definisan tip FILE. Struktura file sadrži atribute koji opisuje datoteku koja je otvorena. Tu postoji i indeks toka, ima i indikator kraja datoteke (toka), ima indikator greške…

FILE *fp; // (ovo moramo da imamo, ako hoćemo 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 pokazivača, da li je kraj, da li je greška, koja je

pozicija pokazivača),4) zatvaranje datoteke;

Otvaranje datoteke: Koristi se funkcija FILE *fopen (char *ime, char *mode), (vraća pointer na FILE).*mode je režim rada. Osnovni režim rada/otvaranaj su: “r” (čitanje iz fajla), “w” (pisanje u fajl), “a” (append, ako fajl postoji biće otvoren, i pokazivač će biti na mjestu poslije svega u datoteci). Postoje i kombinovani režimi “r+” (ima mogućnost čitanja, ali može i pisanje), “w+” (podrazumjeva se čitanje, ali može i pisanje), “a+” (dopisivanje, a može i čitanje (s početka)).Rad sa binarnim datotekama: SVE VAŽI ISTO KAO I ZA TEKSTUALNO, samo se doda ‘b’ na kraj mode.FILE *fp;fp = fopen(ime, “rb”); //otvaranje datoteke (binarne) u režimu za čitanjeTipično 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 može 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 mogućnost i formatiranog čitanja: int fscanf(FILE *dat, const char *format, …);

Upis u datoteku: Posoji mogućnost upisivanja jednog ili više 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 10while (fscanf(fp, “%d”, &x))printf(“%d”, x);while (fscanf(fp,”%f”, &x))printf(“%5.2f”, x);

Binarne datoteke: Čitanje i pisanje može 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 – može biti seek_set (označava početak 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 početakfseek(fp, -1, 2) – posljednji znak u datoteci

Trenutna pozicija dobija se pomoću int ftell(FILE *dat).Premotavanje na početak: void rewind(FILE *dat).

Funkcije za provjeru statusa:Provjera kraja datoteke int feof(FILE *dat).Tipična upotreba:while (!feof(dat)).Provjera da li ima neka greaška int ferror, clearrer(briše greške);

SORTIRANJE:

-preuređivanje rasporeda elemenata kolekcije u skladu sa nekim kriterijumom (dovođenje elemenata kolekcije u odgovarajući poredak.Poredak može biti: rastući (ascending)(strogo rastući i monotono rastući), opadajući (descending)(strogo opadajući i strogo rastući).

Klasifikacija tehnika za sortiranje:1) prema mjestu sortiranja

a. spoljašnje (kolekcija je u sekundarnoj memoriji (datoteke)),b. unutrašnje (kolekcije koje se u potpunosti nalaze u operativnoj memoriji

(nizovi, liste));2) Prema načinu 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 poređenju 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 početka do kraja kroz neuređeni dio kolekcije i izabere se najbolji i doda se na uređeni dio selekcije.Primjer:6 4 1 7 8 5 3 21.prolaz kroz kolekciju tražimo najmanjeg u neuredjenom dijelu:1 4 6 7 8 5 3 22.prolaz:1 2 6 7 8 5 3 4itd...1 2 3 4 5 6 7 8

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 složenosti: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)/2Približno n^2/2 + n/2; (kaže se da ima kvadratno vrijeme);Piše se T(n) = O(n^2); ALGORITAM KVADRATNE SLOŽENOSTI!

Insertion-sort:Prvi iz neuređenog dijela se ubacuje na odgovarajuće mjesto uređenog dijela.Primjer:6 4 1 7 8 5 3 2 – polazna kolekcija, prvi element je uređen odmah.Prvi prolaz (pomjeram 4 ulijevo dok treba) :4 6 1 7 8 5 3 2Drugi prolaz:1 4 6 7 8 5 3 2itd ...1 2 3 4 5 6 7 8

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 složenosti:n-1 prolaz velike petlje. Za manju petlju zavisi koliko je ona uređena.U najboljem slučaju je O(n) (algoritam linearne složenosti). Najgori slučaj mala petlja vrši 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 = 46 4 1 7 8 5 3 2 Prvi prolaz:6 4 1 7 8 5 3 2Drugi prolaz:6 4 1 7 8 5 3 2Treći prolaz:6 4 1 7 8 5 3 2Četvrti prolaz:6 4 1 2 8 5 3 7h = h / 2 = 2;Imamo:6 4 1 2 8 5 3 7Prvi prolaz:1 4 6 2 8 5 3 7Drugi prolaz:1 2 6 4 8 5 3 7Treći prolaz:1 2 6 4 8 5 3 7Četvrti prolaz:1 2 6 4 8 5 3 7Peti prolaz:1 2 6 4 3 5 8 7Šesti prolaz:1 2 6 4 3 5 8 7h = h / 2 = 1;Imamo:1 2 6 4 3 5 8 7Prvi prolaz: 1 2 6 4 3 5 8 7Drugi prolaz:...1 2 3 4 5 6 7 8Source 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 složenosti:

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 kolekcijaDijeli na dvije kolekcije: 6 4 1 7 I 8 5 3 2Zatim 6 4 I 1 7 I 8 5 I 3 2Zatim ponaosob svaki.Zatim se sparuju:46 I 1 7 I 5 8 I 2 3Zatim se sparuju:1 4 6 7 I 2 3 5 8Zatim:1 2 3 4 5 6 7 8

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 složenosti:T(n) = O(n*log(n));linearno-logaritamska složenost;

Bublle-sort:

Primjer:

6 4 1 7 5 3 2Prvi proglaz:4 6 1 7 5 3 24 1 6 7 5 3 24 1 6 7 5 3 24 1 6 5 7 3 24 1 6 5 3 7 24 1 6 5 3 2 7Drugi prolaz:1 4 6 5 3 2 71 4 6 5 3 2 71 4 5 6 3 2 71 4 5 3 6 2 71 4 5 3 2 6 7Treći prolaz:1 4 5 3 2 6 71 4 5 3 2 6 71 4 3 5 2 6 71 4 3 2 5 6 7Četvrti prolaz:1 4 3 2 5 6 71 3 4 2 5 6 71 3 2 4 5 6 7Peti prolaz:1 3 2 4 5 6 71 2 3 4 5 6 7bubble – select – insert – shell (poredak složenosti);

Analiza složenosti: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;

}}

PRETRAŽIVANJE

-Pronalaženje (lociranje) željenog elementa u kolekciji.-s obzirom na to gdje se nalazi kolekcija:

1) unutrašnje (kolekcija je u operativnoj memoriji)2) spoljašnje (kolekcija je u sekundarnoj memoriji – datoteka)

-Kolekcija može biti uređena (sortirana) ili neuređena (nesortirana);

Sekvencijalno pretraživanje (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)Moguće 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 (samoorganizujuće pretraživanje)- neuređena kolekcija- move to front – nakon pronalaženja yapis/element ide na početak- move to back – nakon pronalaženja 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 pretraživanje (pretraživanje polovljenjem intervala): - Kolekcija je uređena- polovimo interval, i tražimo u kojem dalje da pretražujemo.