Lekcija 16 - FESB

Lekcija 17. Rekurzija, složenost algoritama i sortiranje
Rekurzija nastaje kada funkcija poziva samu sebe direktno ili indirektno.
Indirektna rekurzija nastaje kada jedna funkcija poziva drugu funkciju, a ova ponovo poziva funkciju iz koje je
pozvana.
U matematici se često proračun funkcija f(n) definira pomoću rekurzije:
Koristi se pravilo:
1. postavi f(0) "temeljni slučaj"
2. računaj f(n) pomoću f(k) za k < n "pravilo rekurzije"
Primjerice, rekurzivno se može izračunati n! (n-faktorijela), jer vrijedi
za n=0: 0! = 1; (temeljno rekurzije)
za n>0: n! = n * (n-1)! (rekurzivno pravilo)
pa se sve vrijednosti mogu izračunatu pomoću gornjeg rekurzivnog pravila:
1! = 1 * 0! = 1
2! = 2 * 1! = 2
3! = 3 * 2! = 6 ... itd.
int factorial(int n)
{
if (n == 0)
return 1;
else
return factorial(n-1) * n;
}
1

Usporedba rekurzivnih i iterativnih programa
rekurzivni proračun sume
1,2,..n
int sum( int n)
{
if (n ==1)
return 1;
else
return sum(n – 1) + n;
}
iterativni proračun sume 1,2,..n
int sum( int n)
{
int s=0;
while (n)
sum += n--;
return s;
}
redoslijed poziva funkcije
sum(4)
sum(4)
sum(3)
sum(2)
sum(1)
return 1
return 1+2=3
return 3+3 =6
return 6+4 = 10
stanje memorije koja se koristi
za prijenos argumenata funkcije
(stog memorija)
arg. 4
arg. 4 3
arg. 4 3 2
arg. 4 3 2 1
arg. 4 3 2
arg. 4 3
arg. 4
arg. -
Rekurzija je korisna u mnogim slučajevima, posebno kada je njome prirodno definiran problem.
2

Metoda - podijeli pa vladaj (Divide and Conquer)
Opći princip metode ja da se problem podijeli u više manjih problema, pa rješenje potraži u manjim cjelinama
Primjer: Binarno pretraživanje niza
Zadan je sortirani niz cijelih brojeva a[n]
a[i-1]< a[i], za i=1,..n-1
Problem: da li se ovom nizu, izmežu indeksa d i g, nalazi element vrijednosti x.
U tu svrhu koristit ćemo funkciju
int bsearch( int a[],int x, int d, int g);
Problem definiramo rekurzivno na slijedeći način:
1. Temeljne pretpostavke:
Ako u nizu a[i] postoji element jednak traženoj vrijednosti x, njegov indeks je iz intervala [d,g], gdje
mora biti istinito g >= d. Trivijalni slučaj je za d=0, g=n-1, koji obuhvaća cijeli niz.
Razmatramo element niza indeksa i = (g+d)/2. (dijelimo niz na dva podniza)
Ako je a[i]==x, pronađen je traženi element niza i funkcija vraća indeks i.
2. Pravilo rekurzije:
Ako je a[i]

Ilustrirajmo proces traženja vrijednosti x=23 u nizu od 14 elemenata
0 1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 5 6 8 9 12 23 26 27 31 34 42
d i g
1 2 3 5 6 8 9 12 23 26 27 31 34 42
d i g
1 2 3 5 6 8 9 12 23 26 27 31 34 42
d i g
1.korak: d=0, g=13, i=(d+g)/2= 6, a[6]23
3.korak: d=7, g=i-1=9, i=8, a[8]==23
int bsearch( int a[],int x, int d, int g)
{
int i;
if (d > g) return –1; /* ako x nije u nizu*/
i = (d + g)/ 2;
if (a[i] == x)
return i;
if (a[i] < x)
return bsearch( a, x, i + 1, g);
else
return bsearch( a, x, d, i - 1);
}
4

Iteracija kao specijalni slučaj rekurzije
Ekvivalentni iterativni i rekurzivni zapis funkcije petlja()
“tail” rekurzija iteracija 1. ili iteracija 2.
void petlja()
{
iskaz
if (e)
petlja();
}
void petlja()
{
start:
iskaz
if (e) goto start;
}
void petlja()
{
do
iskaz
while (e);
}
Rekurzivni poziv se vrši na kraju (ili na repu) tijela funkcije, stoga se ovaj tip rekurzije naziva "tail" rekurzija ili
"rekurzija na repu".
Na ovaj se način dobija efikasnija funkcija, jer se ne gubi vrijeme i prostor na stogu potreban za poziv funkcije.
Funkciju bsearch, može se lako transformirati u "tail" rekurzivnu funkciju:
int bsearch( int a[],int x, int d, int g)
{
int i;
start: if (d > g) return –1;
i = (d + g)/ 2;
if (a[i] == x) return i;
if (a[i] < x) d=i+1;
else g=i-1
goto start;
}
5

Kule Hanoia
Najpoznatiji rekurzivni problem u kompjuterskoj literaturi - Kule Hanoia.
A B C
Zadatak:
Premjestiti sve diskove s štapa A na štap B u redoslijedu kako se nalaze na štapu A.
Pravila:
1. Odjednom se smije pomicati samo jedan disk.
2. Ne smije se stavljati veći disk povrh manjeg diska.
3. Može se koristiti štap C za smještaj diskova, ali uz poštovanje prethodna dva pravila.
Temeljni slučaj rekurzije:
1. Ako kula A sadrži samo jedan disk, prebaci taj disk na ciljni štap B.
Rekurzivno pravilo :
Ako kula sadrži N diskova, pomicanje diskova se može izvesti u tri koraka
1. Pomaki gornjih N-1 diskova na pomoćni štap C.
2. Preostali donji disk s štapa A pomaki na ciljni štap B.
3. Zatim kulu od N-1 diska s pomoćnog štapa C prebaci na ciljni štap B.
6

Kako napisati funkciju koji izvršava gornje pravilo. Nazvat ćemo je move_tower,
void move_tower(int n, char A, char B, char C);
a argumente koji će nam biti potrebni su:
n- broj diskova koje treba pomaknuti,
A - ime početnog štapa ,
B - ime ciljnog štapa,
C - ime pomoćnog štapa.
void move_disk(char from, char to)
{
printf("%c -> %c\n", from, to);
}
void move_tower(int n, char A, char B, char C)
{
if (n == 1) { /* temeljni slučaj */
move_disk(A, B);
}
else {
move_tower (n - 1, A, C, B); /* 1. pravilo */
move_disk (A, B); /* 2. pravilo */
move_tower (n - 1, C, B, A); /* 3. pravilo */
}
}
7

int main()
{
/* npr. za slučaj 3 diska*/
}
move_tower(3, 'A','B','C');
return 0;
Rezultat:
A -> B,
A -> C,
B -> C,
A -> B,
C -> A,
C -> B,
A -> B
8

SLOŽENOST ALGORITAMA
Kvalitetan je onaj algoritam kojim se postiže efikasno korištenje memorijskog prostora
M(n) -
i prihvatljivo vrijeme obrade
T(n) - vremenska složenost (complexity) (n – dimenzija problema)
"Veliki-O" notacija
Analizirajmo sada segmemt programa u kojem treba sumirati elemente kvadratne matrice, dimenzije n. Također,
označimo broj ponavljanja naredbi (pri tome se podrazumjeva da su signifikantne one naredbe u kojima se vrši
zbrajanje).
NAREDBE PROGRAMA BROJ PONAVLJANJA
-------------------------------------------
S = 0 ; ........
for(i=0; i

Ovaj se zaključak u računarskoj znanosti piše u obliku tzv. "veliki-O" notacije:
T(n) = O [n²]
i kaže se da je T(n) "veliki O od n² ". Funkcija f(n) = n² predstavlja red složenosti algoritma.
Tip algoritma
f(n)
Konstantan
const.
Logaritamski
log 2 n
Linearan
n
Linearno-logaritamski nlog 2 n
Kvadratni n 2
Stupanjski
n k (k>2)
Eksponencijalni
k n (k>1)
Faktorijelni n!
Binarno pretraživanje je LOGARITAMSKI ALGORITM
Opća koncepcija logaritamskih algoritama je slijedeća:
1. Obaviti postupak kojom se veličina problema prepolovi.
2. Nastaviti razlaganje problema dok se ne dođe do veličine 1.
3. Obaviti završnu obradu s problemom jedinične veličine.
Ukupan broj razlaganja k dobije se iz uvjeta:
n / 2k = 1 .
odnosno k= log 2 n. Za binarno pretraživanje T(n) = O(log 2 n)
10

LINEARNI ALGORITMI
Linearni algoritmi se javljaju u svim slučajevima gdje je obradom obuhvaćeno n istovjetnih podataka i gdje
udvostručenje količine radnji ima za posljedicu udvostručenje vremena obrade. Opći oblik linearnog algoritma
može se prikazati u vidu jedne for petlje:
for (i=0; i< n; i++)
{obrada koja traje vrijeme t}
Zanemarujući vrijeme opsluživanja for petlje, u ovom slučaju funkcija složenosti je T(n)=nt, pa je T(n) = O(n).
LINEARNO-LOGARITAMSKI ALGORITMI
Linearno-logaritamski algoritmi (O[n log(n)]) također spadaju u klasu veoma efikasnih algoritama jer im
složenost raste sporije čak i od kvadratne funkcije. Primjer za ovakav algoritam je Quicksort, koji će biti detaljno
opisan kasnije. Bitna osobina ovih algoritama je slijedeća
(1) Obaviti pojedinačnu obradu kojom se veličina problema prepolovi.
(2) Unutar svake polovine sekvencijalno obraditi sve postojeće podatke.
(3) Nastaviti razlaganje problema dok se ne dođe do veličine 1.
Slično kao i kod logaritamskih algoritama i ovdje je ukupan broj polovljenja log 2 n, ali kako se pri svakom
polovljenju sekvencijalno obrade svi podaci, to je ukupan broj elementarnih obrada jednak nlog 2 n, i to predstavlja
rezultantni red funkcije složenosti.
KVADRATNI ALGORITMI
Kvadratni algoritmi (O[n 2 ]) se najčešće dobijaju kada se koriste dvije for petlje jedna unutar druge. Primjer je dat
na početku ovog poglavlja.
STUPANJSKI ALGORITMI
Stupanjski algoritmi se mogu dobiti poopćenjem kvadratnih algoritama, za algoritam s k umetnutih for petlji
složenost je (O[n k ]).
11

EKSPONENCIJALNI ALGORITAMSKI
Eksponencijalni algoritmi (O[k n ]) spadaju u kategoriju problema za koje se suvremena računala ne mogu koristiti,
izuzev u slučajevima kada su dimenzije takvog problema veoma male. Jedan od takovih primjera je algoritam
koji rekurzivno rješava igru "Kule Hanoia", opisan u prethodnom poglavlju.
FAKTORIJELNI ALGORITMI
Kao primjer faktorijelnih algoritama najčešće se uzima problem trgovačkog putnika. Problem je formuliran na
slijedeće način: zadano je n+1 točaka u prostoru i poznata je udaljenost između svake dvije točke j i k. Polazeći od
jedne točke potrebno je formirati putanju kojom se obilaze sve točke i vraća opet u polaznu točku tako da je
ukupni prijeđeni put minimalan.
Trivijalni algoritam za rješavanje ovog problema mogao bi se temeljiti na uspoređivanju duljina svih mogućih
putanja. Broj mogućih putanja iznosi n!. Polazeći iz početne točke postoji n putanja do n preostalih točaka. Kada
odaberemo jednu od njih i dođemo u prvu točku onda nam preostaje n-1 moguća putanja do druge točke, n-2
putanja do treće točke, itd., n+1-k putanja do k-te točke, i na kraju samo jedna putanja do n-te točke i natrag u
polaznu točku. Naravno u literaturi postoje razne efikasnije varijante algoritma za rješavanje navedenog problema,
ali u opisanom slučaju sa jednostavnim nabrajanjem i uspoređivanjem duljina n! različitih zatvorenih putanja
dolazimo do algoritma čije je složenost O(n!).
12

Sortiranje
Ulaz: niz A[n] od n elemenata.
Izlaz: Elementi raspoređeni prema vrijednostima
A[0] min od A[4..5] zamijeni sa A[4]
1 2 3 4 5 6 -> niz je sortiran
13

void selectionSort(int *A, int n)
{
int i, j, imin; /* indeks najmanjeg elementa u A[i..n-1] */
for (i = 0; i < n-1; i++)
{
/* Odredi najmanji element u A[i..n-1]. */
imin = i; /* pretpostavi da je to A[i] */
for (j = i+1; j < n; j++)
if (A[j] < A[imin]) /* ako je A[j] najmanji */
imin = j; /* zapamti njgov indeks */
swap(&A[i], &A[imin]);
}
}
/* Zamjena vrijednosti dva int */
void swap(int *a, int *b)
{
int t = *a;
*a = *b;
*b = t;
}
14

Analiza selekcijskog sortiranja
Uzet ćemo da se svaka naredba izvršava neko konstantno vrijeme. Svaka iteracija vanjske petlje (indeks i) traje
konstantno vrijeme t 1 plus vrijeme izvršenja unutarnje petlje (indeks j). Svaka iteracija u unutarnjoj petlji traje
konstantno vrijeme t 2 .
Broj iteracija unutarnje petlje ovisi u kojoj se iteraciji nalazi vanjska petlja:
Ukupno vrijeme je:
Broj operacija u
i
unutarnjoj petlji
0 n-1
1 n-2
2 n-3
... ...
n-2 1
T(n) = [t 1 + (n-1) t 2 ] + [t 1 + (n-2) t 2 ] + [t 1 + (n-3) t 2 ] + ... + [t 1 + (1) t 2 ]
odnosno, grupirajući članove u oblik t 1 ( …) + (...) t 2 dobije se
T(n) = (n-1) t 1 + [ (n-1) + (n-2) + (n-3) + ... + 1 ] t 2
Izraz u uglatim zagradama predstavlja sumu aritmetičkog niza
1 + 2 + 3 + ... + (n-1) = (n-1)n/2 = (n 2 -n)/2,
pa je ukupno vrijeme jednako:
T(n) = (n-1) t 1 + [(n 2 -n)/2] t 2 = - t 1 + t 1 n - t 2 n/2 + t 2 n 2 /2
Vidimo da dominira član sa n 2 , pa je složenost selekcijskog sortiranja jednaka O(n 2 )
15

Sortiranje umetanjem
Algoritam sortiranja umetanjem (eng. insertion sort), se zasniva na postupku koji je sličan načinu kako se slažu
igraće karte. Ideju demonstrirajmo nizom od 6 brojeva. Algoritam se vrši u u n-1 korak. U svakom koraku se
umeće i-ti element u dio niza koji mu prethodi (A[0..i-1]), tako taj niz bude sortiran.
6 4 1 5 3 2 -> ako je A[1]< A[0], umetni A[1] u A[0..0]
4 6 1 5 3 2 -> ako je A[2]< A[1], umetni A[2] u A[0..1]
1 4 6 5 3 2 -> ako je A[3]< A[2], umetni A[3] u A[0..2]
1 4 5 6 3 2 -> ako je A[4]< A[3], umetni A[4] u A[0..3]
1 3 4 5 6 2 -> ako je A[5]< A[4], umetni A[5] u A[0..4]
1 2 3 4 5 6 -> niz je sortiran
Algoritam se može zapisati pseudokodom:
for (i = 1; i < n; i++)
{
el = A[i];
od indeksa k=i-1, do indeka k=0 analiziraj A[0 .. i-1]
ako je el < A[k], pomakni element A[k] na mjesto A[k+1]
inače prekini
zatim umetni el na mjesto A[j+1]
}
16

Analiza složenosti sortiranja umetanjem
Pokazat ćemo da je sortiranje umetanjem primjer algoritma u kojem prosječno vrijeme izvršenja nije puno kraće
od vremena izvršenja koje se postiže u najgorem slučaju.
Najgori slučaj
Vanjska petla se izvršava u n-1 iteracija, što daje O(n) iteracija. U unutarnjoj petlji se vrši od 0 do i

17.8.3 Sortiranje spajanjem sortiranih podnizova (merge sort)
Sortiranje metodom spajanja sortiranih podnizova (eng. merge sort) temelji se na ideji da se niz rekurzivno dijeli
na dva sortirana niza, te da se zatim izvrši spajanje tih sortiranih nizova.
Problem će biti riješen za slučaj da se sortira niz A[d..g], tj. od donjeg indeksa d do gornjeg indeksa g, funkcijom
void mergeSort(int *A, int d, int g);
Rekurzivnom se podjelom niza u dva podniza, A[d..s] i A[s+1,g], koji su otprilike podjednake veličine (indeks s
se odredi kao srednja vrijednost s = (d+g)/2), dolazi se do temeljnog slučaja kada u svakom nizu ima samo jedan
element. Taj jedno-elementni niz je već sortiran, pa se pri "izvlačenju" iz rekurzije može vršiti spajanje sortiranih
podnizova. Ovaj postupak je ilustriran na slici 4.
Za implementaciju ovog algoritma bitno je uočiti sljedeće:
• Ulazni niz nije nužno "fizikalno" dijeliti na podnizove, jer se podnizovi ne preklapaju. Dovoljno je
zapamtiti indekse ulaznog niza koji određuju neki podniz.
• Spajanje podnizova se uvijek provodi s elementima koji su u ulaznom nizu poredani jedan do drugog; prvi
podniz je A[d..s], a drugi podniz je A[s+1..g]. U tu svrhu koristit će se funkcija:
18

void merge(int *A, int d, int s, int g)
/* Ulaz: dva sortirana niza A[d..s] i A[s+1..g] */
/* Izlaz: sortirani niz A[d..g] */
Očito je da se radi o algoritmu tipa "podijeli pa vladaj":
1. Podijeli: podijeli niz A[d,g], na način da dva podniza A[d,s] i A[s+1,g] sadrže otprilike pojednak broj
elemenata. To se postiže izborom: s=(d+g)/2.
2. Vladaj: rekurzivno nastavi dijeliti oba podniza sve dok njihova veličina ne postane manja od 2 elementa
(niz koji sadrži nula ili jedan element je sortirani niz).
3. Spoji: Nakon toga, pri "izvlačenju" iz rekurzije, izvrši spajanje sortiranih nizova koristeći funkciju
merge(A,d,s,g).
Implementacija ovog algoritma je jednostavna;
void mergeSort(int *A, int d, int g)
{
if (d < r ) { /* temeljni slucaj - 1 element */
int s = (d + g) / 2; /* s je indeks podjele niza */
mergeSort(A, d, s); /* rekurzivno podijeli A[d..s] */
mergeSort(A, s+1, g); /* rekurzivno podijeli A[s+1..g]*/
merge(A, d, s, g); /* zatim spoji sortirane nizove */
}
}
Još treba definirati funkciju merge(). Ona se može realizirati na način da se formiraju dva pomoćna niza, donji[] i
gornji[], u koje se kopira sortirane nizove A[d..s] i A[s+1..g]. Zatim se iz tih pomoćnih sortiranih nizova formira
jedan sortirani niz u području ulaznog niza A[d..g]. Postupak je ilustriran na slici 5.
19

Slika 17.5. Spajanje sortiranih nizova
Implementacija je sljedeća:
/* Spajanje podnizove A[d..s] i A[s+1..g] u sortirani niz A[d..g]. */
void merge(int *A, int d, int s, int g)
{
int m = s - d + 1; /* broj elemenata u A[d..s] */
int n = g - s; /* broj elemenata u A[s+1..g] */
int i; /* indeks u donji niz*/
int j; /* indeks u gornji niz*/
int k; /* indeks u orig. niz A */
int *donji = malloc(sizeof(int) * m); /* niz A[d..s] */
int *gornji = malloc(sizeof(int) * n); /* niz A[s+1..g] */
/* Kopiraj A[d..s] u donji[0..m-1] i A[s+1..g] u gornji[0..n-1]. */
for (i = 0, k = d; i < m; i++, k++) donji[i] = A[k];
for (j = 0, k = s+1; j < n; j++, k++) gornji[j] = A[k];
/* Usporedbom donji[0..m-1] i gornji[0..n-1], pomakni manji na sljedeću poziciju A[d..g].
*/
i = 0; j = 0; k = d;
while(i < m && j < n; )
if (donji[i] < gornji[j]) A[k++] = donji[i++];
else A[k++] = gornji[j++];
20

* Preostale elemente jednostavno kopiraj */
/* Jedna od ove dvije petlje će imati nula iteracija! */
while (i < m) A[k++] = donji[i++];
while (j < n) A[k++] = gornji[j++];
}
/* Dealociraj memoriju koju zauzimaju donji i gornji. */
free(donji); free(gornji);
Operacija kopiranja iz pomoćnih nizova u sortirani niz A[d..g] provodi se jednostavnom usporedbom sadržaja
donji[i] i gornji[j]. Kopira se manji element u A i inkrementira pozicija u nizu. Na taj način, ova se operacija vrši
u linearnom vremenu O(g-d+1).
Pomoćni nizovi su formirani alociranjem memorije, stoga se na kraju funkcije vrši oslobađanje memorije. U
realnoj se primjeni može koristiti brži postupak, bez alociranja memorije, na način da se pomoćni nizovi
deklariraju kao globalne varijable. Dimenzija ovih globalnih nizova mora biti veća od polovine dimenzije niza
koji se sortira. Na sličan način se može provesti i sortiranje datoteka.
Složenost metode spajanja podnizova
Može se na jednostavan način pokazati da je vremenska složenost ovog algoritma jednaka O(n log 2 n), ukoliko se
uzme da je veličina niza potencija broja 2, tj. da je n = 2 m . Pošto se pri svakom rekurzivnom pozivu niz dijeli na
dva podniza, sve dok duljina podniza ne postane jednaka 1, proizlazi da je broj razina podijele niza jednak log 2 n.
Na k-toj razini niz je podijeljen na 2 k podnizova duljine n/2 k . To znači da spajanje sortiranih nizova na k-toj razini
ima složenost 2 k xO(n/2 k )= O(n), a pošto ima log 2 n razina, proizlazi da je ukupna složenost jednaka O(n log 2 n).
Do istog rezultata se dolazi i uz znatno rigorozniju analizu složenosti.
Može se pokazati da je ovo najbolji rezultat koji se može postići pri sortiranju nizova. Jedini problem ovog
algoritma je što zahtijeva povećanu prostornu složenost.
21

Quicksort
Quicksort je rekurzivna metoda sortiranja kojom se u prosječno postiže O(n log 2 n), što je znatno bolje od O(n 2 )
(koji nastaje samo u najgorem slučaju). Često se koristi u praksi. Temelji se na tehnici podijeli pa vadaj.
Neka je problem sortirati dio niza A[p..r]. Koristi se algoritam:
PODIJELI. Izaberi jedan element iz niza A[p..r] i zapamti njegovu vrijednost. Taj element ćemo nazavati
pivot. Nakon toga podijeli A[p..r] u dva podniza A[p..q] i A[q+1..r] koji imaju slijedeća svojstva:
Svaki element A[p..q] je manji ili jednak pivotu .
Svaki element A[q+1..r] je veći ili jednak pivotu.
Niti jedan podniz ne sadrži sve elemente (odnosno ne smije biti prazan).
VLADAJ. Rekurzivno sortiraj oba podniza A[p..q] i A[q+1..r], i problem će biti riješen kada oba podniza
budu imala manje od 2 elementa.
Uvjet da nijedan podniz ne bude prazan je potreban jer kada bi to bilo ispunjeno, tada bi rekuzivni problem bio isti
kao originalni problem, pa bi nastala bekonačna rekurzija.
Pokažimo sada kako podijeliti podnizove da budu ispunjeni postavljeni uvjeti.
Podjela se vrši funkcijom
int partition(int *A, int p, int r)
koja vraća indeks q (gdje je izvršena podjela na podnizove).
22

Logika funkcije partition():
Postupak podjele niza je
ilustriran na nizu A[4..13].
Označeni su indeksi (i,j).
Potamnjeni elementi
pokazuju koje elemente
zamjenjujemo.
Linija podjela je
prikazana u slučaju kada i
postane veći od j.
Za pivot je odabran prvi
element vrijednosti 6.
Podjela se vrši pomoću dva indeksa (i, j) i pivota
koji se odabire kao element A[p], prema pravilu:
i pomičemo od početka prema kraju niza, dok
ne nađemo element A[i] koji je veći ili
jednak pivotu
j pomičemo od kraja prema početku niza, dok
ne nađemo element A[j] koji je manji ili
jednak pivotu
zatim zamjenjujemo vrijednosti A[i] i A[j],
kako bi svaki svaki element A[p..i] bio manji
ili jednak pivotu, a svaki element A[j..r] veći
ili jednak pivotu.
Ovaj se proces nastavlja dok se ne dobije da je
i > j. Tada je podjela završena, a j označava
indeks koji vraća funkcija partition. Ovaj
uvjet ujedno osigurava da nijedan podniz
neće biti prazan.
23

* Podijeli A[p..r] u podnizove A[p..q] and A[q+1..r], gdje je p = j, raspored je OK, inače, zamijeni A[i] sa A[j] i nastavi. */
if (i < j) swap(&A[i], &A[j]);
else return j;
}
}
Pomoću ove funkcije se sada iskazuje kompletni quicksort algoritam:
void quicksort(int *A, int p, int r)
{
if (p < r) /* završava kada podniz ima manje od 2 elementa */
{
int q = partition(A, p, r); /* q je pivot */
quicksort(A, p, q); /* rekurzivno sortiraj A[p..q] */
quicksort(A, q+1, r); /* rekurzivno sortiraj A[q+1..r]*/
}
}
24

Analiza složenosti quicksort algoritma
Prvo uočimo da je vrijeme koje je potrebno za podjelu podnizova od n elemenata, proporcionalno broju
elemenata cn (konstanta c > 0), tj. složenost je O(n). Analizirajmo zatim broj mogućih rekurzivnih poziva.
Najbolji slučaj
U najboljem slučaju nizovi se dijele na dvije jednake polovine. Pošto je tada ukupan broj razlaganja jednak log 2 n
donije se da je složenost O(n)⋅O(log 2 n) = O(n log 2 n).
Najgori slučaj
U najgorem slučaju podjela na podnizove se vrši tako da je u jednom podnizu uvijek samo jedan element. To
znači da bi tada imali n rekurzivnih poziva, pa bi ukupna složenost bila O(n) ⋅O(n)= O(n 2 ). Najgori slučaj nastupa
kada je niz sortiran ili "skoro" sortiran.
Prosječni slučaj
Analiza prosječnog slučaja je dosta komplicirana. Ovdje je nećemo iznositi. Važan je zaključak da se u
prosječnom slučaju dobija složenost koja je bliska najboljem slučaju O(n log 2 n).
Kako odabrati pivot element
U prethodnom algoritmu za pivota je odabran početni element A[p]. U praksi se pokazalo da je znatno povoljnije
odabir pivota vršiti po nekom slučajnom uzorku. Koristi se postupak da se odaberu se tri indeksa po slučajnom
uzorku, a zatim se za pivot odabere jedan od ova tri elementa koji je najbliži srednjoj vrijednosti (median). Ovim
postupkom se još dobija vjerojatnost dobre podjele (50%). Dublje opravdanje ove metode ovdje neće biti dano.
Pokazalo se, da uz primjenu ovakovog postupka, quicksort predstavlja najbrži poznati način sortiranja nizova, pa
je implementiran u standardnoj biblioteci C jezika.
25