SAŽETAK Diplomski rad, kroz teorijsku razradu i prikaz praktične primjene na primjeru aplikacije za pretragu studentskih poslova, obrađuje temu računa

Транскрипт

1

2

3

4 SAŽETAK Diplomski rad, kroz teorijsku razradu i prikaz praktične primjene na primjeru aplikacije za pretragu studentskih poslova, obrađuje temu računarskih algoritama za sortiranje i pretraživanje podataka. Neki od algoritama koji efikasno rade sortiranje su: Sortiranje odabirom, jednostavno sortiranje umetanjem, višestruko sortiranje umetanjem, sortiranje spajanjem i brzo sortiranje. Pretraživanje je postupak traženja točno određenog podatka iz nekog skupa podataka. Neki od algoritama za pretraživanje su: linearno pretraživanje, binarno pretraživanje, binarna stabla pretraživanja i hash tablice. Cilj teorijskog dijela ovog rada je prikazati razlike između nekih od najpoznatijih algoritama za sortiranje i razlike između nekih od najpoznatijih algoritama za pretraživanje. Praktični se dio rada bavi primjenom znanja o razlikama različitih algoritama za sortiranje i pretraživanje pri razvoju aplikacije za mobilne uređaje koja se bavi pretragom putem tražilice iz baze studenstkih poslova. U radu se izlažu osnovne ideje algoritama i daju primjeri njihove realizacije. Pretraživanje putem tražilice obavlja se upisivanjem željene riječi u tražilicu. Praktični dio rada prikazuje dizajn i prototip aplikacije te primjenu najprikladnijeg algoritma za sortiranje i pretraživanje podataka. KLJUČNE RIJEČI Algoritam za sortiranje, Algoritam za pretraživanje, Mobilna aplikacija, Brzo sortiranje, Crveno crna binarna stabla pretraživanja

5 SUMMARY This work, through theoretical and practical elaboration on student job searching application example, discusses the subject of computer algorithms for sorting and searching data. Some of the algorithms that efficiently sort are: selection sort, insertion sort, shell sort, merge sort and quick sort. Searching is a process for searching a specific sata from a set of data. Some of the search algorithms are: sequential search, binary search, binary search tree and hash tables. Theoretical part of this work is to show the differences between sorting algorithms and searching algorithms. Practical part of the work involves searching for student jobs through a search engine in a mobile app. Basic ideas, logic and examples of many algorithms are explained. To search a job user must enter a word that he is looking for in the application. Practical part of this work also shows a design and a simple prototype of this mobile app and the application of the most suitable sorting and searching algorithm. KEY WORDS Sorting alghoritm, Searching alghoritm, Mobile application, Quick sort, Red-black binary saerch tree

6 1. Uvod Algoritmi za sortiranje Osnovni algoritmi za sortiranje Sortiranje odabirom (selection sort) Sortiranje umetanjem (insertion sort) Višestruko sortiranje umetanjem (shell sort) Mjehurićasto sortiranje (bubble sort) Sortiranje češljanjem (comb sort) Koktel sortiranje (cocktail sort) Usporedba osnovnih algoritama za sortiranje Sortiranje spajanjem (merge sort) Silazno sortiranje spajanjem (top-down mergesort) Uzlazno sortiranje spajanjem (bottom-up mergesort) Brzo sortiranje (quick sort) Sortiranje nahrupnjavanjem (heap sort) Usporedba algoritama za sortiranje Algoritmi za pretraživanje Linearno ili slijedno pretraživanje Binarno pretraživanje Binarna stabla pretraživanja Crveno crna binarna stabla pretraživanja Hash tablice Primjena algoritama u aplikaciji za pronalazak studentskih poslova Zaključak Literatura... 70

7 1. UVOD Mnogi današnji problemi rješavaju se algoritmima. Za mnogobrojne računarske probleme s kojima su suočene suvremene aplikacije pronađeni su prikladni algoritmi kojima su problemi otklonjeni. Iz tih razloga, potraga za ispravnim algoritmom prvi je zadatak pri rješavanju problema. Za svaki je problem moguće naći više različitih rješenja. U ovom diplomskom radu objašnjeno je koji su algoritmi najprikladniji za rješavanje pojedinog problema te iz kojeg je razloga upravo taj algoritam najprikladniji. Obično, nisu svi algoritmi jednako dobri u smislu brzine izvođenja. U znanosti je problem sortiranja još uvijek aktualan i traže se bilo kakve mogućnosti ubrzanja kojim bi se problem što prije otklonio. U praksi se često pojavljuje potreba za sortiranjem podataka te se stoga traži što efikasniji i brži algoritam. Iz tog razloga, nedavno se došlo do otkrića algoritma introsort koji je kombinacija dva već poznata algoritma za sortiranje, a brži je od svakog pojedinačnog. U najnižu klasu spadaju najjednostavniji i najsporiji algoritmi poput sortiranja umetanjem ili sortiranja odabirom, dok u najvišu klasu spadaju algoritmi poput brzog sortiranja i sortiranja spajanjem. Kad obrađujemo veliku količinu podataka važno je da su ti podaci sortirani jer takav ustroj olakšava njihovo pretraživanje. Važna je i brzina izvođenja algoritma kao i količina memorije koja se koristi za njegovo izvođenje. Pretraživanje podataka jedna je od fundamentalnih stvari u programiranju i često se koristi u različitim oblicima. Pretraživati se mogu podaci sadržani u telefonskim imenicima, tražilice na webu, popis birača, popis stanovništva, studenata i slično. Cilj svakog pretraživanja je dobiti što precizniju i točniju informaciju u što kraćem vremenskom roku. Naravno, vrsta tražene informacije često ima veliki utjecaj na odabir algoritma za pretragu. Proces pretraživanja je vrlo čest u obradi podataka, pa je poznavanje metoda i tehnika organizacije podataka pretraživanja vrlo važno. Tako su neki od algoritama koji su ujedno i obrađeni u ovom radu linearno ili slijedno pretraživanje, binarno pretraživanje, binarna stabla pretraživanja i Hash tablice. Praktični dio rada bavi se pretragom studentskih poslova, koji su nakon unosa tražene riječi sortirani abecedno, lokacijski i slično, ovisno o tome što je zadano u filteru pretraživanja. Poznavajući big O notaciju i način rada pojedinih algoritama može se zaključiti koji algoritam je najbolji u primjeni za pojedine zahtjevne aplikacije. 1

8 2. ALGORITMI ZA SORTIRANJE Prije pojave prvih računala sortiranje podataka odvijalo se ručno, što je zahtijevalo mnogo truda i vremena ih IBM je napravio prekretnicu: automatizirali su operacije sortiranja i tako, u praksi, za nekoliko godina ubrzali prikupljanje i obradu podataka iz popisa stanovništva u SAD-u [W. Ferreira Filho, Computer science distilled, 2017, str. 83],. Sortiranje ili razvrstavanje je postupak preustroja podataka u nekom logičkom slijedu. Na primjer, računi kreditne kartice poredani su po datumu. To je postignuto uvođenjem algoritama za sortiranje. U ranim se danima računala oko 30% svih računalnih resursa trošilo na postupke sortiranja podataka [R. Sedgewick i K. Wayne, Algorithms, 2011, str. 243]. Danas je taj postotak manji, ponajviše zahvaljujući učinkovitom razvoju bržih i učinkovitijih algoritama, a ne njihovoj manjoj važnosti. Nadalje, sve češće korištenje računala dovelo je do povećane potrebe organiziranja raznih dokumenata i podataka, a prvi korak za njihovo organiziranje često je sortiranje. Svi računalni sustavi primjenjuju algoritme za sortiranje, bilo da ih automatsi pozivaju pozadinski potprogrami ili su pokrenuti od strane korisnika. Sortiranje igra važnu ulogu u komercijalnoj obradi podataka, kao i u znanstvenim istraživanjima. Neke od najvažnijih primjena su kroz aplikacije koje sadrže obradu transakcija, zatim u astrofizici, molekularnoj biologiji, lingvistici, vremenskoj prognozi i mnogim drugim područjima. Nadalje, algoritam za brzo sortiranje (quick sort), o kojem će riječi biti kasnije, proglašen je jednim od deset najvažnijih algoritama u znanosti i inženjerstvu 20. stoljeća. Općenito govoreći, sortirati znači poredati elemente niza od najmanjeg do najvećeg, tj. uzlazno ili od najvećeg do najmanjeg, tj. silazno. U računalnoj znanosti algoritmi za sortiranje su algoritmi koji na određeni način postavljaju elemente niza (polja, liste) u željeni redoslijed. Sortiranja koja se najviše koriste su: leksikografska (sortiranje slova i riječi) i brojevna (sortiranje brojeva). Neki od algoritama sortiranja koji su obrađeni u ovom radu su: Merge sort (sortiranje spajanjem), Bubble sort (mjehurićasto sortiranje), Insertion sort (sortiranje umetanjem), Selection sort (sortiranje odabirom), Heap sort (sortiranje pomoću hrpe), Shell sort (višestruko sortiranje umetanjem), 2

9 Quick sort (brzo sortiranje). Neke od tih metoda pripadaju osnovnoj vrsti algoritama, npr., bubble sort i insertion sort, dok drugi algoritmi pripadaju složenijoj vrsti algoritama poput quick sort algoritma. Prije ulaska u analize pojedinih algoritama, potrebno je razumjeti glavne čimbenike po kojima se u računalnim znanostima razlikuju algoritmi, odnosno big O notacije. Big O prvenstveno opisuje svojstva ili složenost algoritma te se koristi za opis vremena izvršenja zadatka ili za memorijski prostor koji algoritam koristi. O(1) opisuje algoritam koji se izvršava u istom vremenu ili prostoru bez obzira na veličinu ulaznih podataka. Primjer: bool IsFirstElementNull(IList<string> elements) { return elements[0] == null; O(N) opisuje algoritam koji raste linearno i u skladu s veličinom ulaznih podataka. Primjer koji slijedi prikazuje kako se Big O nosi s najgorim mogućim scenarijima. bool ContainsValue(IList<string> elements, string value) { foreach (var element in elements) { if (element == value) return true; return false; Sljedeći algoritam, O(N 2 ), ima svojstva proporcionalna s kvadratom veličine ulaznih podataka. 3

10 bool ContainsDuplicates(IList<string> elements) { for (var outer = 0; outer < elements.count; outer++) { for (var inner = 0; inner < elements.count; inner++) { // Don't compare with self if (outer == inner) continue; if (elements[outer] == elements[inner]) return true; return false; Algoritam O(2 N ) udvostručuje se sa svakim dodatkom u ulazu podataka. Krivulja rasta ovog algoritma je eksponencijalna, dakle u početku niska da bi zatim naglo porasla. Primjer je rekurzivni izračun Fibonaccijevog niza brojeva: int Fibonacci(int number) { if (number <= 1) return number; return Fibonacci(number - 2) + Fibonacci(number - 1); Fibonaccijevi brojevi su niz definiran rekurzivnom relacijom. Često se taj niz povezuje s brojem zlatnog reza fi (φ). Fibonaccijevi brojevi definiraju se na sljedeći način: 4

11 F(n) := { 0 ako je n = 0 1 ako je n = 1 Fn-1 + Fn-2 ako je n > 1 Prvi Fibonaccijevi brojevi, označeni kao Fn, za n = 0, 1,... su: 0, 1, 1, 2, 3, 5, 8, 13, 21,... Logaritamski algoritmi su nešto kompliciraniji. Algoritam O(logN) koristi se u binarnom pretraživanju, koje je obrađeno u poglavlju o algoritmima za pretraživanje. Algoritam O(logN) daje linearno rastuću krivulju koja naglo skoči u početku i zatim se polako izravnava kako se veličina ulaznih podataka (n) povećava. Na primjer, ulaznim podacima s 10 stavaka bit će potrebna 1 sekunda za obradu, podacima sa 100 stavaka 2 sekunde itd. Ovaj algoritam vrlo je učinkovit kada su u pitanju velike količine podataka. U nastavku slijedi vizualni prikaz usporedbe Big O funkcija (slika 1). Slika 1: Usporedba Big O notacije 5

12 2.1 OSNOVNI ALGORITMI ZA SORTIRANJE U ovom poglavlju objašnjeni su neki od osnovnih algoritama za sortiranje: sortiranje odabirom (eng. selection sort) i sortiranje umetanjem (eng. insertion sort). Razlozi zbog kojih su ova dva algoritma posebno izdvojeni od ostalih je njihova jednostavnost kroz koju možemo prikazati kako općenito funkcioniraju algoritmi za sortiranje kroz primjere, naučiti osnovnu terminologiju vezanu za algoritme sortiranja, njihovu primjenu i prednost nad sofisticiranijim algoritmima te njihovu korist u usavršavanju ostalih algoritama Sortiranje odabirom Ideja jednog od najjednostavnijih algoritama sortiranja odabirom oslanja se na sljedeći koncept: u zadanom nizu usporediti svaki element s onim koji se trenutno nalazi na prvom mjestu i, ako je manji, zamijeniti im mjesta. Tako se na kraju dobije najmanji element na prvom mjestu. Postupak se ponavlja za preostale elemente od drugog do zadnjeg mjesta. Dakle, dobivamo poredan niz od najmanjeg elementa na prvom mjestu, dok će na zadnjem mjestu ostati najveći element. Algoritam za sortiranje odabirom je tzv. kvadratne složenosti ili O(n 2 ), koju čine sporiji algoritmi za sortiranje. U praksi se koriste za sortiranje špilova karata. Kod sortiranja odabirom nakon svakog prolaza algoritma nizom uvijek se izvodi samo jedna zamjena elemenata. Elementi koji zamjenjuju mjesta su element koji ima najmanju vrijednost u nesortiranom dijelu liste i prvi element u nesortiranom djelu liste, odnosno element koji slijedi nakon zadnjeg elementa sortiranog dijela liste. Kako bi se pronašao najmanji element u nesortiranom dijelu liste algoritam uspoređuje trenutni element sa sljedećim i ukoliko je sljedeći element manji od trenutnog elementa, taj element postaje najmanji te se dalje uspoređuje sa sljedećim. Tablica 1: Princip rada algoritma za sortiranje odabirom

13 U tablici 1 vidi se princip rada algoritma za sortiranje odabirom, a postupak je sljedeći: algoritam pronalazi najmanji element u nizu i zamjenjuje ga s elementom na prvom mjestu, zatim pronalazi drugi najmanji element i zamjenjuje ga s elementom na drugom mjestu te na kraju ponavlja postupak sve dok se ne sortira čitav niz. Slijedi primjer izgleda samog algoritma za sortiranje odabirom (Java programski jezik). Public class Selection { public static void sort(comparable[] a) { // Sort a[] into increasing order. Int N = a.length; // array length for (int i = 0; i < N; i++) { // Exchange a[i] with smallest entry in a[i+1...n). int min = i; // index of minimal entr. for (int j = i+1; j < N; j++) if (less(a[j], a[min])) min = j; exch(a, i, min); 7

14 Tablica 2: Princip rada algoritma za sortiranje odabirom a[] i min S O R T E X A M P L E 0 6 S O R T E X A M P L E 1 4 A O R T E X S M P L E 2 10 A E R T O X S M P L E 3 9 A E E T O X S M P L R 4 7 A E E L O X S M P T R 5 7 A E E L M X S O P T R 6 8 A E E L M O S X P T R 7 10 A E E L M O P X S T R 8 8 A E E L M O P R S T X 9 9 A E E L M O P R S T X A E E L M O P R S T X A E E L M O P R S T X Crno obojana slova u tablici 2 uspoređuju se kako bi se pronašao minimum. Crveno obojana slova su a[min], a sivo obojana slova su u konačnoj poziciji. Gledajući primjer iz te tablice, dolazimo do zaključka da se sortiranje odabirom izvršava prema sljedećim formulama: usporedba: T(N) = N*(N-1)/2 => O(N) = N 2 zamjena: T(N) = N => O(N) = N Na kraju, dolazimo do zaključka da je glavna prednost algoritma za sortiranje odabirom to što je prijenos podataka minimalan stoga algoritam ne zahtijeva dodatnu memoriju. Nedostatak je to što vrijeme izvođenja algoritma ne ovisi o tome je li dio elemenata niza prethodno sortiran ili ne. Također, pronalaženje minimalnog člana u jednom prolasku ne daje informaciju gdje bi se mogao nalaziti sljedeći minimalni element. 8

15 2.1.2 Sortiranje umetanjem Sortiranje umetanjem (eng. Insertion sort) je algoritam koji se svodi na umetanje novog elementa u već sortirani niz elemenata. To je metoda sortiranja koja sortira niz na način da sve elemente veće od promatranog pomiče za jedno mjesto udesno i na taj način stvara mjesto za promatrani element. Sortiranje umetanjem također spada pod algoritme tzv. kvadratne složenosti. Dok algoritam prolazi poljem, polje se dijeli na dva dijela, na početni ili sortirani dio te na ostatak polja koji nije sortirani. U svakom prolasku algoritma uzima se element s početka nesortiranog dijela i premješta se na pravo mjesto u sortirani dio. Pravo mjesto na koje je pomaknut u tom ponavljanju nije i njegovo posljednje mjesto i pravo mjesto u cjelokupnom rasporedu polja, nego se ono prolaskom svakog ponavljanja može pomaknuti prema naprijed ili nazad ovisno o tome kakav element se dovodi u sortirani dio liste. Prema tome prolaskom kroz cjelokupno polje algoritam duljinu sortiranog dijela povećava za jedan, a duljinu nesortiranog dijela smanji za jedan. Vrlo je učinkovit pri sortiranju velikih količina podataka: function insertion_sort(list) for i 2 list.length j i while j and list[j-1] > list[j] list.swap_items(j, j-1) j j 1 Princip rada za i-ti (i = 1,, N-1) element je sljedeći: Uspoređuje se njegova vrijednost s vrijednošću i-1 elementa i ukoliko je X[i] < X[i-1], i-1 element se pomiče za jedno mjesto u desno, Sljedeći se uspoređuje i-2 element i postupak se ponavlja sve dok se ne nađe element koji je manji od X[i] te se X[i] se umeće iza njega. Primjer funkcije koja sortira niz upotrebom insertion sort algoritma: function InsertionSort( a, n ) for i = 2 to n do 9

16 j = i-1; element = a[i]; while ( j > 0 ) and ( a[j] > element ) do a[j+1] = a[j]; j = j 1; end while end function a[j+1] = element; U nastavku slijedi primjer (tablica 3.) koji prikazuje korake sortiranja niza. U svakom koraku element koji se razmatra je obojan u crveno. Tablica 3: Princip rada algoritma za sortiranje umetanjem Gledajući primjer u tablici 3, dolazimo do zaključka da se sortiranje umetanjem izvršava prema sljedećim formulama: usporedba: T(N) = N*(N-1)/2 => O(N) = N 2 zamjena: W(N) = N 2 /2 i A(N) = N 2 /4 10

17 Za razliku od sortiranja odabirom, red izvršavanja ovog algoritma ovisi o prethodnom rasporedu elemenata jer ako je uvjet sortiranja za neki element zadovoljen odmah se ide na sljedeći bez daljnje usporedbe. Sortiranje umetanjem dobro funkcionira za određene vrste nenasumičnih nizova koji se često pojavljuju u praksi čak i ako su dugački. Tablica 4: Princip rada algoritma za sortiranje umetanjem a[] i j S O R T E X A M P L E 1 0 O S R T E X A M P L E 2 1 O R S T E X A M P L E 3 3 O R S T E X A M P L E 4 0 E O R S T X A M P L E 5 5 E O R S T X A M P L E 6 0 A E O R S T X M P L E 7 2 A E M O R S T X P L E 8 4 A E M O P R S T X L E 9 2 A E L M O P R S T X E 10 2 A E E L M O P R S T X A E E L M O P R S T X U tablici 2, sivo se obojana slova ne miču, crveno obojana slova su a[j], a crno se obojana slova pomiču jednu poziciju udesno. Sortiranje umetanjem ima puno manju efikasnost kod dužih nizova u odnosu na složenije algoritme poput brzog sortiranja ili sortiranja nahrupnjavanjem. Međutim ima i neke prednosti: Jednostavna implementacija Učinkovitiji je u praksi od ostalih jednostavnih algoritama sa istom složenosti (mjehurićasto sortiranje, sortiranje odabirom) Učinkovit na malim skupovima podataka 11

18 Stabilan odnosno ne mijenja relativni redoslijed elemenata sa jednakim vrijednostima Prilagodljiviji za skupove podataka koji su gotovo sortirani u cijelosti Trenutan, online, sortira niz odmah po primanju. Općenito, sortiranje umetanjem izvrsna je metoda za djelomično sortirana polja i također je dobra metoda za sitna polja. Ove činjenice važne su ne samo iz praktičnih razloga, već i zbog toga što se obje vrste polja pojavljuju zajedno kod naprednih algoritama sortiranja, o čemu bude riječi kasnije. Slika 2 prikazuje nam jednostavan vizualni prikaz koji će nam pomoći bolje shvatiti algoritme za sortiranje odabirom i umetanjem. Umjesto praćenja napretka slova, brojeva ili riječi, koriste se okomite crte, sortirane po visini. Prednost ovakvog pristupa objašnjenju je u tome da se može izbliza vidjeti kako se sortiranje ponaša. Primjerice, na prvi pogled s desne strane slike 1, primjećuje se da sortiranje umetanjem ne dodiruje ulaze desno od točke očitanja te da sortiranje odabirom ne dodiruje ulaze lijevo od točke očitanja. 12

19 Slika 2: Vizualizacija osnovnih algoritama za sortiranje Višesturko sortiranje umetanjem Višestruko sortiranje umetanjem (eng. Shell sort) je algoritam sortiranja koji je godine konstruirao Donald Shell. Višestruko sortiranje umetanjem je generalizacija običnog sortiranja umetanjem koja iskorištava činjenicu da sortiranje umetanjem radi jako dobro na poljima koja su već skoro sortirana i poboljšan je na način da dozvoljava usporedbu i zamjenu elemenata koji imaju velik razmak između sebe u odnosu na poredak u polju. Zadnji korak u višestrukom sortiranju umetanjem je originalno sortiranje umetanjem, što znači da uspoređuje susjedne elemente čiji je razmak jedan (slika 3). 13

20 Slika 3: Višestruko sortiranje umetanjem (shell sort) Osnovna zamisao višestrukog sortiranja umetanjem je da se ne uspoređuju susjedni elementi, već se definira veličina koja određuje razmak k1 (gap) između elemenata koji se uspoređuju. Prema veličini razmaka niz se dijeli na podnizove i untar svakog podniza elementi se sortiraju primjenjujući prethodno opisan princip jednostavnog sortiranja umetanjem (insertion sort). Nakon sortiranja svih podnizova za definirani razmak k, taj broj se smanjuje i ponavlja se postupak s brojem k2. U svakoj novoj iteraciji razmak se smanji sve dok se ne dobije vrijednost kn = 1. Za kn = 1 postupak sortiranja svodi se na jednostavno sortiranje umetanjem, ali postupak puno kraće traje budući da je niz jednim dijelom sortiran tijekom prethodno izvedenih postupaka. Postavlja se pitanje kako odrediti početni razmak k1, pa ovisno o tome postoje različite varijante implementacije višestrukog sortiranja umetanjem. Prema Shellu početni razmak odnosno pomak određuje se kao floor(n/2) gdje je n broj elemenata niza, a svaki novi k se dobije dijeljenjem brojem 2. Funkcija floor daje najveći cijeli broj koji je rezultat djeljenja (n/2). Višestruko sortiranje umetanjem jedan je od prvih algoritama za sortiranje čiji je red manji od O(n 2 ). Osnovna ideja kod ovog algoritma je da se uspoređuje i mijenja svaki h ti element te da se h postepeno smanjuje (do 1) što rezultira sotiranim nizom. public class Shell 14

21 { public static void sort(comparable[] a) { // Sort a[] into increasing order. int N = a.length; int h = 1; while (h < N/3) h = 3*h + 1; // 1, 4, 13, 40, 121, 364, 1093,... while (h >= 1) { // h-sort the array. for (int i = h; i < N; i++) { // Insert a[i] among a[i-h], a[i-2*h], a[i-3*h].... for (int j = i; j >= h && less(a[j], a[j-h]); j -= h) exch(a, j, j-h); h = h/3; Ako izmijenimo sortiranje umetanjem kako bismo sortirali polje i dodali vanjsku petlju da se smanji h (do 1), dolazimo do kompaktne implementacije višestrukog sortiranja umetanjem. 15

22 Slika 4: Primjer višestrukog sortiranja niza od 500 elemenata s različitim h Na slici 4 vidimo primjer višestrukog sortiranja niza od 500 elemenata, gdje se h određuje na sljedeći način: h1= N/2, h2= h1/2,, hi= hi-1/2, 1 Niz vrijednosti h (ht, ht-1,, h1) koje se koriste kod Shell sort algoritma nazivaju se niz inkrementa. Mogući su različiti nizovi inkrementa, ali h1 mora biti 1. Neki testirani nizovi inkrementa pokazali su se uspješni u praksi, no najbolji još uvijek nije pronađen. Vrijeme izvršavanja algoritma ovisi o odabiru niza inkrementa. Postoji nekoliko vrsta niza inkrementa: Shellov niz - {1,, (N/2)/2, N/2 = > O(N 2 ) najgori slučaj odabira niza inkrementa. Hibbardov niz - {1, 3, 7,, 2 k -1 = > O(N 3/2 ) u najgorem slučaju, O(N 5/4 ) u prosjeku, što je utvrđeno simulacijom, no nitko nije uspio dokazati. Sedgwickov niz - {1, 5, 19, 41, 109,, u kojem se vrijednosti generiraju po dvije formule: 9*4 i -9*2 i +1 i 4 i -3*2 i +1 (za i = 0: 9*4 0-9* = 1, 4 0-3* = -1; za i = 1: 9*4 1-9* = 19, 4 1-3* = -1; za i = 2: 9*4 2-9* = 109, 4 2-3* = 5; ) = > O(N 4/3 ) u najgorem slučaju, O(N 7/6 ) u prosjeku. 16

23 Slika 5: Vizualizacija shell sort algoritma Slika 5 primjer je vizualizacije algoritma za višestruko sortiranje umetanjem gdje vidimo bolju učinkovitost ovog algoritma u usporedbi s ostalim osnovnim algoritmima sortiranja. Ideja shell sortiranja je poopćenje prethodno opisanog jednostavnog sortiranja umetanjem. Ovakav način sortiranja pokušava izbjeći sporo premještanje nekog elementa velike vrijednosti mjesto po mjesto, kako je implementirano u bubble sort algoritmu. U trenutku kada se počinju uspoređivati susjedni elementi, niz je već jednim dijelom dobro sortiran. Složenost ovog algoritma iznosi O(n 1.5 ), što je bolji rezultat od prethodno opisanih algoritama Mjehurićasto sortiranje Sortiranje u valovima ili mjehurićasto sortiranje (eng. Bubble sort) je jedan od najjednostavnijih algoritama za sortiranje. Sortiranje se može pokrenuti od početka, ali isto tako i od kraja liste. Osnovna ideja algoritma je usporedba svaka dva susjedna elementa liste (niza) te im se mijenjaju mjesta ako poredak nije dobar. Nakon jednog prolaska kroz listu najveći element biva izguran na kraj liste, odnosno ispliva kao mjehurić otkud dolazi i sam naziv algoritma. Takav postupak se ponavlja sve dok cijela 17

24 lista nije sortirana. Lista se u svakom trenutku dijeli na dvije podliste, sortiranu i nesortiranu, odvojene konceptualnim zidom. Mjehurićasto sortiranje efikasno je samo za relativno maleni broj elemenata koji se sortiraju, a za veći broj elemenata ova metoda sortiranja je prespora. Princip rada: Kreće se od kraja niza i uspoređuju se dva susjedna elementa. Ukoliko je desni manji mijenjaju im se mjesta. Usporedba se ponavlja sve dok najmanji element ne dođe na prvu poziciju. Nakon toga usporedba ponovo kreće od zadnjeg elementa kako bi se pravi element doveo na drugu poziciju. Tablica 5: Princip rada mjehurićastog sortiranja Tablica 5 radi na principu sljedećeg koda: void BubbleSort (int X[]){ int i, j; for(i = 0; i < N-1; i++) { 18

25 for(j = N-1; j > i; j--) if(x[j-1] > X[j]) zamijeni (X, j-1, j); Red izvršenja: usporedbi: T(N) = N*(N-1)/2 => O(N) = N 2 zamjene: T(N) = N*(N-1)/2 => O(N) = N 2 Slijedi još jedan primjer mjehurićastog sortiranja niza ( ). Prvi prolaz: ( ) ( ), razmjena jer je 6 > 1 ( ) ( ), razmjena jer je 6 > 4 ( ) ( ), razmjena jer je 6 > 3 ( ) ( ) Drugi prolaz: ( ) ( ) ( ) ( ), razmjena jer 4 > 3 ( ) ( ) ( ) ( ) Treći prolaz: ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) Iz gore primjera primjeti se da je niz bio sortiran već nakon drugog prolaza. Međutim, da bi se to utvrdilo, potrebno je bilo napraviti još jedan prolaz. 19

26 Uvjet koji osigurava parcijalnu korektnost je da ako funkcija bilo_razmjena vraća vrijednost 0 prije provjere uvjeta izlaska iz petlje, onda je niz a sortiran (tj. njegov početni dio dužine n). Invarijanta unutarnje petlje koja ispunjava spomenuti uvjet je da ako promjenjiva bilo_razmjena ima vrijednost 0, onda je dio niza a[0, i] sortiran. Završetkom unutarnje petlje i ima vrijednost n-1, te je uvjet ispunjen. Pošto je algoritam zasnovan na razmjenama, invarijanta algoritma je i da se (multi)skup elemenata niza ne mijenja tijekom njegovog izvršenja. Invarijanta označava nepromjenjivost određene veličine. Bubble sort stoji jako loše kad je u pitanju složenost algoritama jer ima najlošiju složenost koju označavamo sa O(n 2 ) gdje je n broj elemenata koji sortiramo. Takva složenost dolazi od toga što za implementaciju koristimo dvije for petlje od kojih jedna služi za usporedbu svaka dva susjedna elementa dok druga prolazi preko cijelog djela nesortiranog niza. Čak i drugi algoritmi s istom složenosti, poput sortiranja umetanjem, imaju potencijal da budu puno bolji i efikasniji od mjehurićastog sortiranja. Dakle, za veliki n ovaj algoritam nam nije praktičan kao u slučaju kad imamo samo par elemenata za sortiranje pa tu ima prednost zbog svoje jednostavnosti. Isto tako velika prednost koju ima u odnosu na algoritme sa boljom složenosti je sposobnost otkrivanja da imamo sortirani niz ugrađen u algoritam. U tom slučaju kad je na ulazu sortirani niz složenost mjehurićastog sortiranja postaje O(n) što je i najbolji slučaj. U određivanju složenosti samog algoritma značajnu ulogu imaju pozicije elemenata u nizu pa se tako mali elementi s kraja niza pomiču na početak jako sporo dok je situacija s velikim elementima s početka niza drugačija jer se oni lako kreću prema kraju i mijenjaju. Programeri su razvili više poboljšanih verzija mjehurićastog sortiranja kao što su koktel sortiranje i sortiranje češljanjem čime su dobili puno na efikasnosti i brzini samog algoritma Sortiranje češljanjem Sortiranje češljanjem (eng. Comb sort) je algoritam sortiranja kojeg je godine konstruirao Wlodzimierz Dobosiewicz. Sortiranje češljanjem je poboljšanje mjehurićastog sortiranja i čak konkurira algoritmu brzog sortiranja. Osnovna ideja je bila eliminacija kornjača, odnosno malih vrijednosti blizu kraja liste pošto je taj problem uvelike usporavao mjehurićasto sortiranje. Kada se u mjehurićastom sortiranju uspoređuju dva elementa, oni uvijek imaju isti razmak, udaljenost jedan od drugog, koji 20

27 iznosi 1. Ideja primijenjena u sortiranju češljanjem je da taj razmak može biti puno veći od 1. Sortiranje češljanjem je također baziran na toj ideji, no on je poboljšanje sortiranja umetanjem, a ne mjehurićastog sortiranja. Razmak, odnosno interval počinje kao dužina liste podijeljena s faktorom sažimanja. Vrijednost faktora sažimanja određena je kao konstanta 1.3 te se lista sortira s tom vrijednošću kao interval usporedbe. Nakon toga razmak, odnosno interval je podijeljen s faktorom sažimanja i lista je sortirana pomoću novog intervala. Taj proces konstantnog smanjivanja intervala se ponavlja sve dok interval ne postane 1. Kada je interval usporedbe 1, izvodi se originalno mjehurićasto sortiranje isto kao što se to događa u višestrukom sortiranju umetanjem koji izvodi originalno sortiranje umetanjem Koktel sortiranje Koktel sortiranje (eng. cocktail sort) je algoritam sortiranja polja zasnovan na mjehurićastom sortiranju. Glavna razlika između ta dva algoritma sortiranja je u tome da koktel sortiranje sortira polja u oba smjera. Pod pojmom oba smjera podrazumijeva se da nakon što bi usporedbom elemenata došao do kraja niza odnosno do krajnje desne strane počeo bi uspoređivati vrijednosti natrag prema početku, odnosno prema lijevoj strani. Ime koktel sortiranje je dobio baš zbog tog prolaženja niza lijevo desno čime se dobiva iluzija miješanja koktela. Koktel sortiranjem se manje vrijednosti pomiču ulijevo pri prolasku algoritma sa desne strane prema početku liste odnosno na lijevu stranu. Niti jedna od ovih modifikacija mjehurićastog sortiranja ne vode boljem rješenju od sortiranja umetanjem, premda sortiranje umetanjem nije pogodno za velike liste Usporedba osnovnih algoritama za sortiranje Nakon što su obrađena dva osnovna algoritma za sortiranje, sortiranje odabirom i sortiranje umetanjem, prirodno je zapitati se koji je algoritam brži, odnosno učinkovitiji. Ispit toga se može pokazati kodom. public class SortCompare { public static double time(string alg, Double[] a) 21

28 public static double timerandominput(string alg, int N, int T) { // Use alg to sort T random arrays of length N. double total = 0.0; Double[] a = new Double[N]; for (int t = 0; t < T; t++) { // Perform one experiment (generate and sort an array). for (int i = 0; i < N; i++) a[i] = StdRandom.uniform(); total += time(alg, a); return total; public static void main(string[] args) { String alg1 = args[0]; String alg2 = args[1]; int N = Integer.parseInt(args[2]); int T = Integer.parseInt(args[3]); double t1 = timerandominput(alg1, N, T); // total for alg1 double t2 = timerandominput(alg2, N, T); // total for alg2 StdOut.printf("For %d random Doubles\n %s is", N, alg1); StdOut.printf(" %.1f times faster than %s\n", t2/t1, alg2); Nakon pokretanja koda u programu, odabirom dvostrukih vrijednosti između 0.0 i 1.0, ispisuje se omjer ukupnog broja puta pokretanja te se dobiva rezultat da je sortiranje umetanjem 1,7 sekundi brže nego sortiranje odabirom. 22

29 2.2 SORTIRANJE SPAJANJEM Sortiranje spajanjem (eng. Merge sort) bazira se na jednostavnom postupku poznatom kao spajanje: kombiniraju se dva poredana niza u jedan veliki niz. Ovaj postupak odmah dovodi do jednostavne ponavljajuće metode sortiranja poznate kao sortiranje spajanjem: sortira se niz, podijeli na dva dijela koja se zatim sortiraju te naposlijetku spajaju dajući konačan rezultat. Jedno od glavnih prednosti sortiranja spajanjem je to što omogućuje sortiranje bilo kojeg niza N u vremenu proporcionalnom Nlog(N). Glavni nedostatak Merge sort algoritma je to što koristi dodatni prostor proporcionalan s N. Tablica 6: Pregled sortiranja spajanjem ulaz M E R G E S O R T E X A M P L E lijevo sortiranje E E G M O R R S T E X A M P L E desno sortiranje E E G M O R R S A E E L M P T X rezultat A E E E E G L M M O P R R S T X U tablici 6 jasno se vidi upotreba dobro poznate ideje podijeli pa vladaj i to na sljedeći način: Niz V se podijeli na lijevi i desni dio otprilike po polovici, nakon toga se rekurzivno sortira posebno lijevi i posebno desni dio, te se nakon toga niz ponovno spaja u jedan sortirani niz. Spajanje je sada jednostavno jer je lijevi i desni dio već sortiran. Rad algoritma se može opisati ovako: niz se prepolovi, pa se nakon toga i te polovice prepolove, sve dok se ne dođe do niza duljine 1. Polovice duljine 1 se dalje ne dijele jer one već jesu sortirani nizovi, postupak spajanja će napraviti ostatak posla. Osnovna ideja se može malo detaljnije opisati sljedećim algoritmom: Sort(V,d,g) ako je g d <= 1 kraj s = (d+g/2) Formiraj V L = {Vd,...,Vs Formiraj V D = {Vs+1,...,Vg Sort(VL,d,s) 23

30 Sort(VD,s+1,g) V=Merge(VL,VD) Sort je rekurzivna funkcija koja sortira niz V sa zadanom donjom granicom d i gornjom granicom g. Prva točka može se opisati kao nerekurzivni izlazak iz funkcije, od druge do četvrte točke imamo razdvajanje niza V na lijevi V L i desni V D dio. U petoj i šestoj točki imamo dva rekurzivna poziva iste funkcije samo s malo drugačijim parametrima. U sedmoj točki funkcije Sort nije detaljno opisan postupak spajanja lijevog i desnog dijela niza koji su već sortirani natrag u V. Slika 6: Prikaz rekurzvinog stabla koje generira sortiranje spajanjem prilikom izvođenja Rekurzivno stablo (slika 6) nam pomaže tako što se može utvrditi da se na svakom nivou stabla uvijek nalazi ukupno N elemenata niza bez obzira da li je niz V razbijen na 2 ili više dijelova, pa sve do zadnjeg nivoa gdje se mogu naći samo nizovi duljine 1. Sljedećim kodom prikazano je ukratko kako sortiranje spajanjem izgleda u programiranju, odnosno u praksi. public static void merge(comparable[] a, int lo, int mid, int hi) { // Merge a[lo..mid] with a[mid+1..hi]. int i = lo, j = mid+1; 24

31 for (int k = lo; k <= hi; k++) // Copy a[lo..hi] to aux[lo..hi]. aux[k] = a[k]; for (int k = lo; k <= hi; k++) // Merge back to a[lo..hi]. if (i > mid) a[k] = aux[j++]; else if (j > hi ) a[k] = aux[i++]; else if (less(aux[j], aux[i])) a[k] = aux[j++]; else a[k] = aux[i++]; Sljedeća metoda u tablici 7 je metoda koja se spaja prvo kopiranjem u pomoćni red aux[] zatim natrag prema a[]. U spajanju, postoje 4 stanja: lijeva polovica ispušta (uzima s desne strane), desna polovica ispušta (uzima s lijeve strane), trenutni ključ s desna manji je od ključa s lijeva (uzima s desne strane) te trenutni ključ s desne strane veći je ili jednak trenutnom ključu s lijeva (uzima s lijeva). Tablica 7: Merge sort primjer funkcioniranja a[] aux[] k i j ulaz E E G M R A C E R T kopija E E G M R A C E R T E E G M R A C E R T A 0 6 E E G M R A C E R T 1 A C 0 7 E E G M R C E R T 2 A C E 1 7 E E G M R E R T 3 A C E E 2 7 E G M R E R T 4 A C E E E 2 8 G M R E R T 5 A C E E E G 3 8 G M R R T 6 A C E E E G M 4 8 M R R T 7 A C E E E G M R 5 8 R R T 8 A C E E E G M R R 5 9 R T 9 A C E E E G M R R T 6 10 T rez. A C E E E G M R R T 25

32 Iako je red ovog algoritma O(N*logN) rijetko se koristi za sortiranja zbog sljedećih problema: spajanje dva sortirana niza zahtijeva korištenje dodatne memorije koja je proporcionalna veličini ta dva niza, vrijeme koje se troši na prebacivanje elemenata iz privremenog niza u originalni (to je moguće izbjeći ako se mijenja uloga privremenog i originalnog niza). Prednosti su: algoritam je postojan, za razliku od quicksort i heapsort algoritama o kojima će riječ biti malo kasnije. Merge sort algoritam pristupa uzastopnim elementima, pa je pogodan za sortiranje vezanih listi, gdje se može pristupati samo uzastopnim elementima. Merg sort algoritam se koristi kao osnova algoritama za eksterno sortiranje Silazno sortiranje spajanjem Silazno sortiranje spajanjem (eng. Top-down mergesort) koristi između 1/2Nlog N i Nlog N usporedbe za sortiranje bilo kojeg niza duljine N. Primjer silaznog sortiranja spajanjem u praksi. public class Merge { private static Comparable[] aux; // auxiliary array for merges public static void sort(comparable[] a) { aux = new Comparable[a.length]; // Allocate space just once. sort(a, 0, a.length - 1); private static void sort(comparable[] a, int lo, int hi) { // Sort a[lo..hi]. if (hi <= lo) return; int mid = lo + (hi - lo)/2; sort(a, lo, mid); // Sort left half. sort(a, mid+1, hi); // Sort right half. merge(a, lo, mid, hi); // Merge results. 26

33 Slika 7: Silazno sortiranje spajanjem Da bismo sortirali podniz a[lo..hi] mora se podijeliti na dva dijela: a[lo..mid] i a[mid+1..hi], sortirati ta dva dijela neovisno jedan o drugome (rekurzivno) te naposlijetku spojiti dobivene podnizove da se dobije konačan rezultat (slika 7). Kako bi se sortiranje spajanjem ubrzalo za 10-15%, predlaže se korištenje sortiranja umetanjem u slučaju manjih podnizova koji se trebaju sortirati (duljine do 15 ili manje). Također, vrijeme obrade sortiranja spajanjem može se ubrzati da bude linearno za redove koji su već poredani tako da se dodaje test kojim se preskače poziv na spajanje ako je a[mid] manje ili jednako a[mid+1]. Ovaj slučaj možemo si predočiti slikom 8. 27

34 Slika 8: Vizualizacija silaznog sortiranja spajanjem s više manjih spajanja u procesu Uzlazno sortiranje spajanjem Merge sort algoritam dijeli niz na dvije polovice (čija se dužina razlikuje najviše za 1), rekurzivno sortira svaku od njih te zatim objedinjuje sortirane polovice. Problem nastaje kada je za objedinjavanje neophodno koristiti dodatni, pomoćni niz. Na kraju se izvršava vraćanje objedinjenog niza iz pomoćnog u polazni. Izlaz iz rekurzije je slučaj jednočlanog niza (slučaj praznog niza ne može nastupiti). Funkcija mergesort sortira dio niza a[1,d], uz korištenje niza tmp kao pomoćnog. void mergesort_(int a[], int l, int d, int tmp[]) { 28

35 if (l < d) { int i, j; int n = d - l + 1, s = l + n/2; int n1 = n/2, n2 = n - n/2; mergesort_(a, l, s-1, tmp); mergesort_(a, s, d, tmp); merge(a + l, n1, a + s, n2, tmp); for (i = l, j = 0; i <= d; i++, j++) a[i] = tmp[j]; Promjenjiva n čuva broj elemenata koji se sortiraju u okviru ovog rekurzivnog poziva, a promenljiva s čuva središnji indeks u nizu između 1 i d. Rekurzivno se sortira n1=n/2 elemenata između pozicija 1 i s-1 i n2 = n n/2 elemenata između pozicija s i d. Nakon toga, sortirani podnizovi se objedinjuju u pomoćni niz tmp. Primijeti se na ovom mjestu korištenje pokazivačke aritmetike. Adresa početka prvog sortiranog podniza koji se objedinjava je a+1, dok je adresa početka drugog a + s. 29

36 Slika 9: Vizualizacija uzlaznog sortiranja spajanjem s više manjih spajanja u procesu Na slici 9 vidi se kako uzlazno sortiranje spajanjem funkcionira. Započinje se prolazom 1-sa-1 spajanja (uzimajući u obzir posebne predmete kao podnizove veličine 1), zatim se prelazi na prolaz 2-sa-2 spajanja (spajaju se podnizovi veličine 2 da bi stvorili podnizove veličine 4), zatim 4-sa-4 i tako dalje. Drugi podniz može biti manji od prvog u zadnjem spoju svakog prolaza (što ne stvara problem za merge()), ali inače sva spajanja uključuju podnizove jednakih veličina, udvostručujući velečinu sortiranog podniza za sljedeći prolaz. public class MergeBU { private static Comparable[] aux; // auxiliary array for merges public static void sort(comparable[] a) { // Do lg N passes of pairwise merges. 30

37 int N = a.length; aux = new Comparable[N]; for (int sz = 1; sz < N; sz = sz+sz) // sz: subarray size for (int lo = 0; lo < N-sz; lo += sz+sz) // lo: subarray index merge(a, lo, lo+sz-1, Math.min(lo+sz+sz-1, N-1)); Slika 10: Uzlazno sortiranje spajanjem Uzlazno sortiranje spajanjem sastoji se od niza prolaza kroz cijeli niz, radeći sz-sa-sz spajanja, počevši sa sz=1 i udvostručujući sz u svakom prolazu (slika 10). Konačni podniz je veličine sz samo u slučaju kada je veličina niza jednaka višekratniku broja sz (inače je manji od sz). 2.3 BRZO SORTIRANJE Kao što samo ime kaže, brzo sortiranje (eng. quick sort) je najbrži poznati algoritam za sortiranje. Taj algoritam se koristi više nego bilo koji drugi. Brzo sortiranje je rekurzivni algoritam za sortiranje koji se služi metodom podijeli pa vladaj. Rekurzivni algoritam 31

38 je algoritam koji poziva samog sebe sve dok se ne postigne određeni uvjet. Algoritam brzog sortiranja uspoređuje elemente u nizu pa spada u algoritme sortiranja uspoređivanjem. Rezultat je pokušaja ubrzavanja faze spajanja u algoritmu sortiranja spajanjem (Merge sort); ovdje je spajanje u potpunosti izbjegnuto, jer nakon što su elementi u podnizovima sortirani, zbog uređenosti niza, svi su elementi iz drugog podniza veći od svakog elementa iz prvog podniza. Osnova ovog algoritma je da se odabire jedan element u nizu koji se naziva referentna točka (eng. pivot), a svi ostali elementi razvrstavaju se ispred i iza stožera ovisno o tome da li su manji ili veći od stožera. Brzo sortiranje popularan je algoritam iz razloga što ga nije teško implementirati, radi dobro za različite vrste ulaznih podataka te je brži od bilo kojeg drugog algoritma za sortiranje. Za male nizove (N 20) performanse quick sort algoritma i nisu baš dobre, zbog toga je preporuka koristiti insertion sort koji rezultira i sa 15% boljim performansama. Prosječno vrijeme izvršavanja ovog algoritma je O(N*logN), najgore vrijeme izvršavanja je O(N 2 ) ali se lako može postići da vjerojatnost da on nastupi eksponencijalno pada. Osnovna ideja algoritma za brzo sortiranje je: ako je broj elemenata u nizu X0 ili X1 vrati se iz funkcije, odaberi bilo koji element niza kao referentnu točku (pivot) v podijeli niz X na X1 i X2 : X1 = {x S {v / x v, X2 = {x S {v / x v, Vrati {quicksort(x1 ), v, quicksort(x2). Kod sortiranja spajanjem, polje je podijeljeno na dva dijela; kod brzog sortiranja, pozicija podjele ovisi o sadržajima polja (Slika 11). Slika 11: Brzo sortiranje (quick sort) 32

39 Brzo sortiranje je rekurzivni program koji sortira podniz a[lo...hi] koristeći partition() metodu koja postavlja a[i] na mjesto i uređuje ostatak ulaza tako da rekurzivni pozivi dovrše sortiranje (Slika 12). public class Quick { public static void sort(comparable[] a) { StdRandom.shuffle(a); // Eliminate dependence on input. sort(a, 0, a.length - 1); private static void sort(comparable[] a, int lo, int hi) { if (hi <= lo) return; int j = partition(a, lo, hi); sort(a, lo, j-1); // Sort left part a[lo.. j-1]. sort(a, j+1, hi); // Sort right part a[j+1.. hi]. 33

40 Slika 12: Prikaz brzog sortiranja kao rekurzivnog algoritma Slika 13: Raspodjela i zamjena elemenata u brzom sortiranju Nakon razvrstavanja elemenata prema zadanom uvjetu element pod nazivom referentna točka nalazi se na mjestu u kojem će se nalaziti i u polju sa rezultatom sortiranja. Sortiranje se dalje izvodi rekurzivnim sortiranjem lijevog i desnog podniza odnosno primjenom brzog sortiranja na ta dva podniza. Razvrstavanje elemenata s lijeve na desnu stranu odvija se tako da se pomiču pokazivači (eng. pointers) s lijeve strane polja na desnu sve tako dugo dok su uvjeti zadovoljeni odnosno da su elementi s lijeve strane manji od referentne točke, a elementi s desne strane veći. Ako bi se oba pokazivača zaustavila na 34

41 2 elemenata to bi značilo da su nađena dva elementa koja se nalaze s krive strane referentne točke te oni zamjenjuju mjesta i nastavlja se pomicanje pokazivača diljem niza. Prolaz pokazivača nizom se završava ukoliko se oni prekriže odnosno oba nađu na istom elementu. Proces takvog razvrstavanja elemenata unutar nizova prikazan je slikom 13. Problemi koji se javljaju kod brzog sortiranja su: pravila ne definiraju jasno što se radi s elementima koji su jednaki referentnoj točki (v), odabir referentne točke, odabir podjele elemenata. Krivi način odabira stožera jer odabir prvog elementa u nizu kao stožera, što je u redu ako su elementi slučajno raspoređeni. Ako su elementi djelomično sortirani na početku tada jedan podniz sadrži gotovo sve elemente i rekurzivnim pozivima se situacija dodatno pogoršava. Siguran način bio bi odabrati stožer slučajno (slika 14). To najčešće daje dobre rezultate, ali problem je neslučajno generiranje brojeva i brzina generiranja slučajnog broja. Najbolji stožer bio bi element koji je srednja vrijednost svih elementa niza i to sljedećom metodom: slučajno se odaberu tri elementa i računa se njihova srednja vrijednost. Zatim uzmu se krajnji lijevi (indeks=l), krajnji desni (D) i središnji element (indeks (L+D)/2) i njihova srednja vrijednost se uzme kao stožer. 35

42 Slika 14: Odabir podjele u brzom sortiranju Odabir referentne točke [L = 0, D = 9, S=(0+9)/2 = 4 ] - usporede se i sortiraju L, S i D elementi i onaj sa srednjom vrijednošću postaje stožer i pomiče se na zadnje mjesto. Brojač i se određuje tako da upućuje na prvog člana, a j na predzadnjeg člana. Dok je i lijevo od j uspoređuju se elementi sa stožerom: i se pomiče u desno ako je elelement manji od stožera, staje ako nije; j se pomiče u lijevo ako je element veći od stožera, staje ako nije; ako su se i i j zaustavili, i pokazuje na veliki a j na mali element, ti elementi mijenjaju mjesta. Kada brojač i prijeđe na desnu stranu referentnog elementa, a brojač j na lijevu, referentni se element poistovjećuje sa i-tim elementom Tablica 8: Odabir stožera v Svi elementi s indeksom manjim od stožera su manji od njega, a svi elementi čiji je indeks veći od stožera su veći od njega (Tablica 8). 36

43 Brojači i i j se trebaju ponašati na isti način jer će inače svi elementi jednaki stožeru završiti u jednom podnizu. Postoje dvije mogućnosti koje se razmatraju na primjeru niza s identičnim elementima: ukoliko se i i j zaustavljaju, dolazi do velikog broja zamjena među istim elementima, ali u konačnici će se i i j sresti u sredini iz čega proizlazi da se osnovni niz dijeli na dva približno jednaka podniza => O(N*logN). Ukoliko se i i j ne zaustavljaju, i će doći do kraja niza bez ijedne zamjene, ali tada stožer ostaje na zadnjem mjestu i sortiranje se opet poziva za gotovo jednako velik niz, tj. podnizovi su vrlo različiti => O(N 2 ) private static int partition(comparable[] a, int lo, int hi) { // Partition into a[lo..i-1], a[i], a[i+1..hi]. int i = lo, j = hi+1; // left and right scan indices Comparable v = a[lo]; // partitioning item while (true) { // Scan right, scan left, check for scan complete, and exchange. while (less(a[++i], v)) if (i == hi) break; while (less(v, a[--j])) if (j == lo) break; if (i >= j) break; exch(a, i, j); exch(a, lo, j); // Put v = a[j] into position return j; // with a[lo..j-1] <= a[j] <= a[j+1..hi]. Unutar petlje, povećamo i dok a[i] je manji od v i smanjimo j dok je a[j] veći od v, zatim radimo zamjenu kako bi se očuvalo nepromjenjivo svojstvo koje kaže da ulazi slijeva elementa i nisu veći od v i da ulazi zdesna od j nisu manji od v. Jednom kada se indeksi susretnu, privedemo podjelu kraju zamjenom a[lo] sa a[j]. Slika 15 prikazuje primjer primjene algoritma za brzo sortiranje. 37

44 Slika 15: Podijela u procesu brzog sortiranja Za jako male nizove veličine manje od 20 elemenata brzo sortiranje ne radi tako dobro kao sortiranje umetanjem. Iz razloga što je brzo sortiranje rekurzivan algoritam slučajevi sortiranja malih nizova događat će se vrlo često. Kao rješenje spomenutog problema, predlaže se korištenje algoritma koji ima bolje performanse u sortiranju nizova manjih dimenzija poput sortiranja umetanjem. Još bolji način bio bi da se ostavi niz skoro pa sortiran i završi sortiranjem umetanjem. Takva strategija bi bila vrlo dobro jer je sortiranje umetanjem iznimno učinkovito na skoro pa sortiranim nizovima, a i uštedjelo bi se oko 15 % vremena izvođenja algoritma. Algoritam brzog sortiranja, koliko god da je brz, programeri nastoje dodatno poboljšati. Optimizacija algoritma brzog sortiranja moguća je boljim izborom stožer elementa. Može se uzeti medijan od prvog, srednjeg i zadnjeg elementa (usporede se ta tri i izabere se srednji među njima za stožer). Najbolja izvedba algoritma: za indeks pivot elementa se uzima slučajni broj, to je algoritam slučajnog brzog sortiranja (randomized quicksort). Druga mogućnost optimizacije je upotreba nekog drugog algoritma sortiranja za kratke pod-nizove, npr. kad se u dijeljenju niza dođe do podnizova od primjerice 5 elemenata, njihovo sortiranje se izvede sortiranjem umetanjem (ili mjehurićastim sortiranjem). Primjer za složeniju verziju koda: za referentni broj se uzima srednji po veličini od 38

45 elemenata koji su na prvom, srednjem i zadnjem mjestu u nizu, a sortiranje pod-nizova kraćih od četiri elementa se provodi algoritmom sortiranja umetanjem. 2.4 SORTIRANJE NAHRUPNJAVANJEM Sortiranje nahrupnjavanjem je algoritam sortiranja koji su konstruirali W. Floyd i J. W. J. Williams godine. Koristi strukturu podataka nazvanu hrpa (eng. heap) kako bi sortirao niz. Kako bi se niz sortirao najprije je potrebno izgraditi hrpu od elemenata koji se nalaze u nizu, pa se prema tome jedan po jedan element redom stavljaju na hrpu. Nakon što se hrpa formira, s vrha hrpe se uzima najveća vrijednost i sprema na kraj niza koji se sortira. Položaj koji taj element zauzima u nizu je i njegov završni položaj, odnosno položaj koji će imati u rezultatu nakon sortiranja. Hrpa se ponovno formira za ostatak nesortirane liste nakon što se uzeo najveći element i opet postavlja najveću vrijednost na vrh. Svakim prolazom, odnosno stvaranjem hrpe i skidanjem elementa s hrpe, veličina hrpe i nesortiranog dijela niza se smanjuje za 1, a sortirani dio povećava za 1 sve tako dugo dok na hrpi ne ostane samo jedan element koji onda čini niz od jednog elementa i sigurno je sortiran te zauzima prvo mjesto u sortiranom polju. Slika 16: Primjer hrpe Struktura hrpe (slika 16) je binarno stablo u kojem za svaki čvor vrijedi da je vrijednost u čvoru veća ili jednaka od vrijednosti svih njegovih sljedbenika. Lista se pretvara u hrpu, a korijenski čvor je sigurno najveći element liste. Korijenski čvor hrpe se izuzima i stavlja se na kraj sortirane liste, tj. hrpa se skraćuje za 1 element i ponovno podešava. 39

46 Slika 17: Dodavanje elementa u heap sort algoritmu Kod dodavanja elementa X na hrpu (slika 17), X se dodaje na iduće slobodno mjesto ako to ne narušava svojstvo hrpe. U prazni element se premiješta njegov roditelj i tako se prazni element diže na višu razinu sve dok se ne nađe mjesto za X uz uvjet da je zadovoljeno pravilo hrpe. Slika 18: Brisanje elementa u heap sort algoritmu Brisanje elementa u ovom slučaju znači brisanje minimalnog (root) elementa, odnosno stvara se prazni element na vrhu stabla te se briše zadnji dodani element, a njegova vrijednost se smješta na hrpu: u prazni element ako je to moguće ili se manji od dvoje djece pomiče na prazno mjesto i stvara novo prazno mjesto, postupak se ponavlja dok se zadnji element ne smjesti (slika 18). 40

47 Slika 19: Binarno stablo Tablica 9: Niz A B C D E F G H I J Hrpu kao potpuno binarno stablo, zbog pravilne strukture, moguće je prikazati pomoću niza i na taj način izbjeći pokazivače (slika 19, tablica 9). Pri tome za element i u nizu vrijedi: lijevo dijete se nalazi na poziciji 2*i, desno dijete se nalazi na poziciji 2*i + 1, roditelj se nalazi na poziciji i/2. Za pronaći djecu ili roditelje nisu potrebni pokazivači nego osnovne matematičke operacije. Sortiranje hrpom dobro je objašnjeno korak-po-korak tablicom 10. Tablica 10: Koraci sortiranja hrpom Hrpa Zamjena elemenata Brisanje elemenata Sortirani niz 8, 6, 7, 4, 5, 3, 2, 1 8, 1 1, 6, 7, 4, 5, 3, 2, 8 8 1, 6, 7, 4, 5, 3, 2 1, 7 8 7, 6, 1, 4, 5, 3, 2 1,

48 7, 6, 3, 4, 5, 1, 2 7, 2 8 2, 6, 3, 4, 5, 1, , 6, 3, 4, 5, 1 2, 6 7, 8 6, 2, 3, 4, 5, 1 2, 5 7, 8 6, 5, 3, 4, 2, 1 6,1 7, 8 1, 5, 3, 4, 2, 6 6 7, 8 1, 5, 3, 4, 2 1, 5 6, 7, 8 5, 1, 3, 4, 2 1, 4 6, 7, 8 5, 4, 3, 1, 2 5, 2 6, 7, 8 2, 4, 3, 1, 5 5 6, 7, 8 2, 4, 3, 1 2, 4 5, 6, 7, 8 4, 2, 3, 1 4, 1 5, 6, 7, 8 1, 2, 3, 4 4 5, 6, 7, 8 1, 2, 3 1, 3 4, 5, 6, 7, 8 3, 2, 1 3, 1 4, 5, 6, 7, 8 1, 2, 3 3 4, 5, 6, 7, 8 1, 2 1, 2 3, 4, 5, 6, 7, 8 2, 1 2, 1 3, 4, 5, 6, 7, 8 1, 2 2 3, 4, 5, 6, 7, , 3, 4, 5, 6, 7, 8 1,2,3,4,5,6,7,8 Složenost heap sort algoritma je O(logn) te kada se to obavlja n puta tada je složenost heap sorta O(n*logn). Iako je vrijeme potrebno za sortiranje niza O(N*logN) u praksi je sporiji od Shell sort algoritma sa Shellovim nizom. Najveći je problem što ovaj algoritam zahtijeva dodatnu memoriju, proporcionalnu veličini originalnog niza. 2.5 USPOREDBA ALGORITAMA ZA SORTIRANJE Mnogi algoritmi iste učinkovitosti nemaju istu brzinu za isti ulaz. Postoji nekoliko važnih kriterija za prosuđivanje algoritama. Prvo, algoritme treba uspoređivati na temelju 42

49 prosječnog, najboljeg i najgoreg slučaja. Neki algoritmi, kao npr. quick sort koji slovi kao jedan od najboljih algoritama, izuzetno dobro obavlja posao za većinu ulaza, dok je za neke druge dosta lošiji. S druge strane, algoritmi kao npr. heap sort, ne zavisi toliko o ulaznim podacima. Drugi kriterij je memorijski prostor koji označava količinu pomoćnog prostora za pohranu i izmjene niza elemenata. Tu imamo tzv. in-place algoritme koji ne zahtijevaju nikakav dodatni prostor za obavljanje zadatka (insertion sort, shell sort, bubble sort), dok drugi algoritmi (quick sort) zahtjevaju dodatno mjesto na stogu. Treći je kriterij stabilnost algoritma. Algoritam je stabilan ako zapisi s jednakim ključevima ostaju u originalnom poretku, odnosno drugim riječima ako iste elemente ostavlja u postojećem poretku. U tablici 11, supoređuju se algoritmi po raznim parametrima. N je broj elemenata niza koji se sortira. Tablica 11: Usporedba algoritama sortiranja Algoritam Stabilan Složenost algoritma Dodatni prostor Brzina za N = Selection sort ne N ,375 s Insertion sort da Između N i N ,610 s Shell sort ne N log N 1 0,062 s Quick sort ne N log N lg N 0,047 s Merge sort da N log N N 0,070 s Heap sort ne N log N 1 0,414 s Insertion sort ima kvadratnu složenost čime se povećava vrijeme sortiranja. Drugim riječima, njegova efikasnost drastično se smanjuje na nizovima s više podataka. Općenito, insertion sort je relativno učinkovit za male nizove te se koristi kao dio sofisticiranijih programa. Heap sort nije toliko efikasan za kraće nizove, ali kako ima logaritamsku složenost vidimo da se povećanjem elemenata niza, otprilike u istom rangu povećava i vrijeme izvođenja. Preostala dva sortiranja shell sort i quick sort pokazali su se vrlo efikasnim posebno na velikim nizovima. Od svih pet testiranih algoritama, najbolja svojstva i najbrža vremena sortiranja pripadaju naravno quick sort algoritmu. 43

50 3. ALGORITMI ZA PRETRAŽIVANJE Moderna računalna znanost i internet omogućili su pristup velikom broju informacija. Sposobnost za učinkovito pretraživanje tih informacija osnova je za njihovo procesuiranje. U ovom poglavlju obradit će se klasični algoritmi za pretraživanje za koje se sa sigurnošću može reći da su učinkoviti, što je dokazano kroz bezbroj aplikacija u kojima su prisutni desetljećima. Bez tih algoritama, razvoj čitave računalne infrastrukture u kojoj danas uživamo ne bi bio omogućen. Algoritam za pretraživanje je algoritam koji daje rješenje nekog problema nakon evaluacije skupa mogućih rješenja. Skup svih mogućih rješenja problema naziva se prostor pretraživanja. Obzirom na njihovu složenost, algoritmi mogu biti osnovni algoritmi pretraživanja, među koje spadaju linearno ili slijedno pretraživanje (sequential search) i binarno pretraživanje (binary search). Također, nešto složeniji algoritmi za pretraživanje su binarno stablo pretraživanja (binary search trees) te hash tablice (hash tables). 3.1 LINEARNO ILI SLIJEDNO PRETRAŽIVANJE Linearno ili slijedno ili sekvencijalno pretraživanje (eng. Sequential search) najjednostavnije je i najčešće pretraživanje, ali ujedno i najlošije, odnosno najsporije jer pretražuje sve elemente niza. Ako imamo n elemenata u skupu kojeg pretražujemo u najgorem slučaju porebno je O(n) operacija. Traženi element se nalazi na posljednjem mjestu. U najboljem slučaju potrebno je O(1) operacija. Traženi element se nalazi na prvom mjestu. Ako postoji niz od, primjerice, 100 tisuća elemenata i željeni element se nalazi na samom kraju, pretraživanje će potrajati prilično dugo. Princip rada je, dakle, prilično jednostavan: nakon unosa željenog elementa, pretražuju se svi članovi niza u bazi i uspoređuju s traženim elementom. Nakon provjere svakog elementa u nizu pojedinačno i po redu, dolazi se do ispisa traženog elementa u slučaju da je pronađen ili do ispisa, primjerice, broja -1 ako je rezultat negativan, odnosno nije pronađen traženi element. 44

51 Slika 20: Primjer linearnog pretraživanja Slika 20 prikazuje niz elemenata među kojima se traži broj 75. Slijedi slika 21 gdje je dijagramom toka prikazana logika po kojoj radi linearno pretraživanje. Slika 21: Dijagram toka za linearno pretraživanje 45

52 Slijedi kod u programskom jeziku C# koji linearno pretražuje i vraća indeks traženog elementa, a ako traženi element nije unutar skupa vraća -1. Parametar poljezapretrazivanje prikazuje niz iz kojeg se traži element, a parametar trazenibroj označava broj koji se traži. Algoritam se sastoji od jedne for petlje koja kao početnu vrijednost ima 0, a kao krajnju vrijednost ima veličinu niza. private static int LinearnoPretrazivanje(int[] poljezapretrazivanje, int trazenibroj) { for (int i = 0; i < poljezapretrazivanje.length; i++) { if (poljezapretrazivanje[i] == trazenibroj) return i; return -1; Dobro je istaknuti, uz već spomenutu jednostavnost, još jednu prednost linearnog pretraživanja, a to je da se algoritam može primijeniti na već neobrađen niz, za razliku od algoritama u nastavku koji zahtijevaju da lista bude sortirana. 3.2 BINARNO PRETRAŽIVANJE Ukoliko je niz po kojem se pretražuje sortiran, moguće je značajno skratiti pretraživanje. Binarno pretraživanje radi sa sortiranim nizom u kojem mora biti omogućen izravan pristup svim elementima liste (važno kod npr. pretraživanja slogova datoteke). Osnovna ideja binarnog pretraživanja je podjela niza u pod-nizove. Na početku se odrede tri indeksa: low i high koji označavaju početak i kraj niza/pod-niz, te mid koji označava srednji element niza/pod-niza. U sljedećem koraku se tražena vrijednost uspoređuje s mid indeksom te se onda dalje rasčlanjuje lijevi ili desni pod-niz sve dok vrijednost mid indeksa ne bude jednaka traženoj. Srednja vrijednost mid se računa po sljedećem izrazu: 46

53 mid = (low + high) / 2 U navedenom izrazu, low označava indeks prvog elementa pod-niza, indeks high zadnji element pod-niza i mid koji je indeks srednjeg elementa pod-niza. Ukoliko je broj elemenata u pod-nizu paran, rezultat za mid indeks se zaokružuje na donju vrijednost. Kod binarnog pretraživanja, za razliku od linearnog, pretraživanje započinje od elementa koji je u sredini uređenog niza, a ne na početku niza provjerom svakog elementa po redu. Ako je tražena vrijednost manja od vrijednosti srednjeg elementa, onda se ona može nalaziti samo u lijevoj polovici niza, u suprotnom je u desnoj. Prosječan broj pretraživanja je log2 n-1, gdje je n broj elemenata u listi. Slika 22: Dijagram toka za binarno pretraživanje Na slici 22 opisan je, doduše nešto kompliciraniji jer se koristi višestruki upit, primjer binarnog pretraživanja. Nakon unosa traženog elementa, pronalazi se centralni element niza. Zatim se odbacuje polovica liste i pretražuje ona druga polovica. Nastavlja se 47

54 pretraživanje sve dok se traženi element ne pronađe ili dok ne ostane niti jedan element za pretraživanje (ispiše se rezultat npr. nije pronađeno). U sljedećem kodu, pisanom u C#, prikazano je binarno pretraživanje koje vraća indeks traženog elementa, ako traženi element nije unutar skupa vraća -1. Parametar poljezapretrazivanje je niz iz kojeg se traži, a parametar trazenibroj je broj koji se traži. private static int BinarnoPretrazivanje(int[] poljezapretrazivanje, int trazenibroj) { int low = 0, high = poljezapretrazivanje.lenght 1, mid = 0; while (low <= high) { mid = (high + low) / 2; if (trazenibroj == poljezapretrazivanje[mid]) return mid; else if (trazenibroj < poljezapretrazivanje[mid]) high = mid 1; else low = mid + 1; return -1; Ukratko, binarno pretraživanje je mnogo brže od linearnog pretraživanja i koristi se u mnogim aplikacijama. Ponajviše iz razloga što je niz sortiran i što se pretraživanje obavlja od srednjeg člana niza. No, mana ovog algoritma kao i kod većine algoritama je memorija algoritam je jednostavno prespor za obradu velikih nizova. 48

55 3.3 BINARNA STABLA PRETRAŽIVANJA Kod ove grupe algoritama implementacija je nešto složenija, no jednako dobro primjenjiva i na skupove statičkih i na skupove dinamičkih podataka. Operacije nad strukturama podataka, koji omogućavaju uspješnost ovih algoritama, su zahtjevnije u pogledu memorije, rada procesora i samog programa. No, algoritmi pretraživanja strukture stabla čine jezgru tehnika pretraživanja. Pretražuju se tzv. čvorovi (eng. root) stabla koji se uzimaju iz strukture podataka te se generiraju njihovi sljedbenici (eng. leaves ili listovi ili djeca) i dodaju u strukturu (slika 23). Stablo se sastoji i od lijevog i desnog pod-stabla (eng. left and rigth sub-tree) koja su sama za sebe binarna stabla. Struktura reda koristi se za čuvanje generiranih i još neistraženih čvorova. Slika 23: Binarno stablo pretraživanja Ključni pojmovi koje je važno znati, a vezani su za stablo: ključ: određeni podatak traženog elementa u algoritmu korijen: čvor na vrhu stabla od kojeg počinju sve operacije sa stablom (može imati 0, 1 ili 2 djece) list: čvor na dnu stabla, najdalji od korijena i nema djece visina: broj veza (grana) koje moraju proći putem od korijena do najdaljeg lista u stablu 49

56 Redoslijed kojim se čvorovi pohranjuju u red za ispitivanje i uklanjanje određuje tip pretraživanja. Postoje dva osnovna načina pretraživanja strukture stabla: pretraživanje u širinu (eng. breadth-first search) i pretraživanje u dubinu (eng. depth-first search). Kod pretraživanja u širinu ispituju se svi čvorovi na određenoj razini prije prelaska na slijedeću razinu. Pretraživanje u dubinu pretražuje poniranjem niz stablo što je brže moguće tako da uvijek generira djecu zadnjeg proširenog čvora dok ne dođe do rješenja (ili dok ne prijeđe zadani limit dubine). Algoritam pretraživanja u dubinu razlikuje se od onog u širinu po redoslijedu kojim je taj čvor stavljen u red - novostvorena djeca stavljaju se na početak reda tako da se ona prva ispituju (slika 24). Slika 24: Pretraživanje strukture stabla po širini i dubini. Binarno stablo pretraživanja najjednostavniji je oblik pretraživanja stablom. Primjenjuje se na skupovima podataka koji se dinamički mijenjaju jer se njegova struktura učinkovito popravlja prilikom ubacivanja ili brisanja elemenata. U uređenom binarnom stablu vrijedi sljedeće: ključevi svih čvorova u lijevom pod-stablu manji su od onoga u korijenu, ključevi svih čvorova u desnom pod-stablu veći su od onoga u korijenu, lijevo i desno pod-stablo su binarna stabla uređena sama za sebe. Pretraga binarnim stablom pretraživanja izgledalo bi ovako u programskom jeziku C: int bin_stab_pret(cvor *korijen, int k) { 50

57 Cvor pom = korijen; while((pom!=null) && (k!=pom->kljuc)) { if(k < pom->kljuc) { pom = pom->lijevo_dijete; else { pom = pom->desno_dijete; return pom; Funkciji predajemo korijen stabla (Cvor) i željeni ključ. Čvor u sebi sadrži pokazivač na desnog i lijevog potomka, kao i ključ koji čvor sadrži. Funkcija vraća pokazivač na čvor koji je rezultat pretrage (u slučaju neuspješne pretrage - null). Binarna stabla pretraživanja značajno imaju značajno unaprijeđenje u odnosu na binarno pretraživanje kada se radi o dinamičkim strukturama koje zahtijevaju često dodavanje novih objekata. Binarna stabla pretraživanja za dodavanje i brisanje objekata koriste operaciju O(logn). Dodavanje vrijednosti u binarna stabla radi na sljedeći način. Ako je element koji se postavlja u stablo manji ili jednak vrijednosti u korijenu stabla, on se postavlja u lijevo pod-stablo, a ako je veći, u desno. Postupak se ponavlja za odgovarajuće pod-stablo, do trenutka kada pod-stablo u koje treba postaviti element ne postane prazno. Tada konstruiramo stablo koje se sastoji samo od jednog čvora. Čvoru je dodana vrijednost koju dodajemo u stablo i to pod-stablo se povezuje s čvorom kroz koji smo prošli neposredno prije toga. Da bi se obrisala vrijednost, prije svega nužno je pronaći čvor kojem je pridružena vrijednost koju uklanjamo. Ako dati čvor ima najviše jedno dijete, onda se to dijete veže s njegovim prethodnikom. Ako dati čvor ima oboje djece, onda se tom čvoru pridružuje informacija iz čvora koji ima najviše jedno dijete, a potom se taj čvor briše. Međutim, da bi se zadržala sva svojstva stabla za pretraživanje, taj čvor koji brišemo ne može biti proizvoljno izabran. Nova vrijednost koju upisujemo u pronađeni čvor je najmanja vrijednost iz njegovog desnog pod-stabla. 51

58 3.3.1 Crveno crna binarna stabla pretraživanja Crveno crno stablo je samobalansirajuće binarno stablo pretraživanja s još jednom dodatnom informacijom za svaki čvor: bojom. Ta boja može biti crvena ili crna. Takodje je neophodno pripaziti na roditelja svakog čvora, tako da bi struktura čvora crveno-crnog stabla bila: struct t_red_black_node { enum { red, black colour; void *item; struct t_red_black_node *left, *right, *parent; Tijekom ovog razmatranja, NULL čvorovi koji završavaju stablo su listovi i obojeni su u crno. Ako je čvor crven, tada je oboje djece crno (ili ne mora imati dijete). Svaki izravan put iz nekog čvora u bilo koji list ispod njega sadrži isti broj crnih čvorova. Crni čvor može imati bilo koju kombinaciju djece osim jednog crnog djeteta. Na putu od korijena do lista ne smiju biti dva susjedna crvena čvora, ali bilo koji broj crnih čvorova može se pojaviti jedan za drugim (slika 25). Slika 25: Osnovno crveno crno stablo 52

59 Slika 26: Osnovno crveno crno stablo s dodanim stražarskim čvorovima Ugradnje algoritama s crveno-crnim čvorovima obično uključuju stražarske čvorove kao standardan način za prepoznavanje da se došlo do lista (slika 26). Broj crnih čvorova na svakom putu iz čvora x (ne uključujući x) do bilo kojeg lista, zove se crna visina čvora i označava sa bh(x). Crveno-crno stablo s n unutarnjih čvorova ima visinu najviše 2log(n+1). Sada se vidi zašto je crveno-crno stablo dobro stablo za pretraživanje: ono se uvijek može pretražti u O(log n) koraka. Kao i s gomilama, dodavanja i brisanja iz crveno-crnog stabla poremećuju crveno-crne osobine, stoga ih je potrebno popravljati. Da bismo to učinili, neophodno je da pogledamo nekoliko operacija na crveno-crnim stablima. Rotacije su osnovna operacija za popravljanje strukture stabla, i to ne samo crveno crnog stabla već bilo kojeg binarnog stabla budući da nisu vezane za boje čvorova. Većina samobalansirajućih struktura koristi rotacije kao dio samobalansirajćeg procesa. Dvije su vrste rotacija, ulijevo i udesno. Prilikom upotrebe lijeve rotacije, pretpostavljamo da desno dijete promatranog čvora nije NULL. Ako je x promatrani čvor, a y njegovo desno dijete, tada se rotacija ulijevo odvija oko veze x-y, na način da tada y postaje korijen, x postaje lijevo dijete od y, a lijevo dijete od y postaje desno dijete od x. Kod desne rotacije imamo obrnutu stvar. Neka je sada y promatrani čvor a x njegovo lijevo dijete, tada rotacijom u desno x postaje roditelj, y desno dijete od x, a desno dijete od x postaje lijevo dijete od y (slika 27). 53

60 Slika 27: Rotacija na binarnom stablu Rotacije su korisne iz tri razloga: 1. Čuvaju svojstva binarnog stabla. Jedan od načina provjere te tvrdnje je da uočimo da je redoslijed čvorova s lijeva na desno jednak u oba slučaja. 2. Izvršavaju se u konstantnom vremenu jer mijenjamo pokazivače kod samo četiri čvora: zelenog, plavog, roditelja gornjeg čvora te čvora B. 3. Mogu se koristiti za prilagodbu visina pod-stabala unutar binarnog stabla. Druga operacija je dodavanje. Kako bi čvor bio umetnut, prvo se mora pronaći odgovarajuće mjesto u stablu. Procedura je jednaka kao kod binarnog stabla pretraživanja, uspoređuje se ključeve čvorova i pomoću usporedbe putuje po stablu dok se ne dođe do odgovarajućeg NULL čvora. Umjesto NULL čvora, stavlja se željeni čvor, a njemu pridružuje dva NULL čvora umjesto djece. Nakon umetanja, čvoru se pridružuje crvena boja. Zatim se provjerava roditelj novoga čvora, kako bi se utvrdilo je li došlo do kršenja nekog od svojstava. Ukoliko dođe do prekršaja, potrebno je pozvati proceduru za popravak kao bi se uspostavila struktura stabla. Taj proces ili vraća sva crveno crna svojstva, ili problematičnu situaciju pomiče gore uz stablo. To se odvija u konstantnom vremenu. Nakon toga se rekurzijom vraćaju svojstva u log vremenu. Treća operacija je brisanje. Proces brisanja nekog čvora započinje se tako da se prvo pronađe u stablu čvor koji treba izbrisati. Ako je čvor list, samo ga se izreže iz stabla. Ako čvor ima jedno dijete, čvor se izbacuje, zamjenjuje njegovim sljedbenikom, te se briše čvor koji je njegov sljedbenik zauzimao. U svim slučajevima briše se čvor s najviše jednim djetetom. 54

61 Sljedeći kod prikazuje čvor crveno crnog binarnog stabla pretraživanja. private static final boolean RED = true; private static final boolean BLACK = false; private class Node { Key key; // key Value val; // associated data Node left, right; // subtrees int N; // # nodes in this subtree boolean color; // color of link from // parent to this node Node(Key key, Value val, int N, boolean color) { this.key = key; this.val = val; this.n = N; this.color = color; private boolean isred(node x) { if (x == null) return false; return x.color == RED; 3.4 HASH TABLICE Hash tablica (eng. Hash table) ili hash mapa (eng. Hash map) je podatkovna struktura koja rabi funkciju hash za učinkovito preslikavanje određenih ključeva (na primjer imena ljudi) u njima pridružene vrijednosti (npr. telefonske brojeve). Hash funkcija se koristi za pretvaranje ključa u indeks (hash), tj. mjesto u nizu elemenata gdje treba tražiti 55

62 odgovarajuću vrijednost. U najboljem slučaju, hash funkcija preslikava svaki mogući ključ u zaseban indeks, ali to je u praksi gotovo nemoguće. Većina implementacija hash tablica podrazumijeva da su hash kolizije (sudara) parovi različitih ključeva s istim hash vrijednostima obična pojava, i na neki način se brine da se ovaj problem svlada. U dobro dimenzioniranoj hash tablici, prosječna cijena (broj računalnih naredbi) svakog pronalaženja ne ovisi o broju elemenata uskladištenih u tablici. Mnoge implementacije hash tablica također omogućuju proizvoljna unošenja i brisanja parova ključeva i vrijednosti uz konstantnu prosječnu (amortiziranu) cijenu po operaciji. U mnogim okolnostima, hash tablice se pokazuju učinkovitijim od stabala pretrage ili drugih tabličnih struktura. Zato su hash tablice u širokoj upotrebi u svim vrstama računarskog softvera. Slika 28: Hash tablica na primjeru telefonskog imenika Slika 28 prikazuje ilustraciju hash tablice na jednostavnom primjeru telefonskog imenika, s tri ključa, bez kolizije već samo s istaknutim vrijednostima. Hash tablice se obično upotrebljavaju za implementaciju svih vrsta tablica koje se čuvaju u memoriji. Koriste se za implementaciju asocijativnih nizova (nizova čiji su indeksi proizvoljni nizovi ili drugi kompliciraniji objekti), posebno u interpretiranim programskim jezicima kao što su gawk i perl. Hash tablice mogu se koristiti i za perzistentne strukture podataka koje su smještene na disku, i za indekse baza podataka, iako su balansirana stabla popularnija za ove primjene. Osim vraćanja vrijednosti koja odgovara danom ključu, mnoge implementacije hash tablica mogu također odgovoriti i na pitanje postoji li takav unos ili ne. Zbog toga se ove strukture mogu rabiti i za 56

63 implementaciju skupa, koji odgovara na pitanje postoji li dani ključ u nekom skupu ključeva. U ovom se slučaju struktura može pojednostaviti eliminiranjem svih dijelova koji se tiču vrijednosti koje odgovaraju ključevima. Hash tablice mogu se koristiti za implementaciju i statičkih i dinamičkih skupova. Ako imamo skup od n elemenata čiji su ključevi jedinstveni cijeli brojevi u intervalu (1,m), gdje je m >= n, tada se elementi mogu smjestiti u tablicu s direktnim adresiranjem T[m], gdje je Ti ili prazno polje ili sadrži jedan element iz skupa. Pretraživanje tablice s izravnim adresiranjem je O(1) operacija: za ključ k pristupamo polju Tk (ako je prazno, vraćamo NULL, a ako sadrži element vraćamo ga. Dva su ograničenja u ovom slučaju: ključevi moraju biti jedinstveni i opseg ključeva mora biti ozbiljno ograničen. Glavna prednost hash tablice nad drugim tabličnim strukturama podataka je njena brzina. Ova je prednost uočljivija kada je broj podataka u tablici velik (tisuće ili više). Hash tablice su posebno učinkovite kada se maksimalna količina podataka može predvidjeti unaprijed, tako da se veličina strukture može unaprijed alocirati tako da bude optimalna, i ne mora se kasnije mijenjati. Ako su svi parovi ključeva-vrijednosti fiksirani i poznati unaprijed (pa dodavanja i brisanja nisu dopuštena), prosječna cijena pretrage može se smanjiti pažljivim izborom hash funkcije, veličine tablice i unutrašnjih struktura podataka. Štoviše, tada je moguće napraviti hash funkciju koja ne stvara kolizije. U ovom slučaju ključeve nije potrebno čuvati u tablici. Kao i kod većine algoritama, hash tablice također bolje rade s manje nizova jer kod većeg broja zadanih nizova potrebno je i više memorije i nešto više vremena za izvođenje. Potrebna je i dobra hash funkcija za svaku vrstu ključa. Isto tako, kvaliteta hash funkcije važna je za bolju učinkovitost ovog algoritma. 57

64 4. Primjena algoritama u aplikaciji za pronalazak studentskih poslova Osnovni cilj aplikacije je lakše snalaženje studenata u moru poslova koji se nude. Također, cilj aplikacije je i da poslodavci lakše pronađu radnike. U eri mobilnih telefona, rapidnog razvoja web i mobilnih aplikacija te općenito ubrzanog stila življenja, potrebno je smišljati dobre i praktične aplikacije kako bi ljudima olakšale život. Najvažnije komponente jedne aplikacije za pretragu dostupnih poslova su algoritmi za sortiranje i pretraživanje. Algoritam za pretraživanje koji je ispao najprikladniji za aplikaciju je crveno crno binarno stablo pretraživanja. Razlog zbog kojeg sam odabrao upravo ovaj algoritam je što je, osim iznimne brzine linearnog uspona (O(log n)), za razliku od binarnog stabla pretraživanja vrlo balansiran. Svaki ključ ili vrijednost (Key or Value) koja se unese upotrijebi se u mnogo operacija i sve to pod cijenu relativno male potrošnje memorije, što je još jedna prednost. Algoritam za sortiranje koji sam koristio je brzo sortiranje. Razlog što sam upravo taj odabrao je velika brzina sortiranja podataka kada su veliki nizovi u pitanju. Algoritmi su pisani u programskom jeziku Java koji je prikladan za mobilne aplikacije (Android). Aplikacija je programirana u Android Studiu. Slika 29: Početni ekran aplikacije 58

65 Na početnom ekranu aplikacije (slika 29), nalazi se lista 50 tvrtki koje oglašavaju svoje ponude studentskih poslova. Na svakoj su ponudi odmah napisane navažnije informacije koje trebaju studentu: satnica, ime tvrtke, opis posla i datum do kada su prijave za posao. Klikom na željenu tvrtku, otvara se novi, podatkovno specifičniji ekran s mogućnošću prijave na posao (slika 30). Slika 30: Ekran za prijavu na posao Slijedi čvor crveno crno binarnog stabla pretraživanja. public class Node<Key, Value> { Key key; Value val; Node<Key, Value> left, right; int N; boolean color; 59

66 public Node(Key key, Value val, int N, boolean color) { this.key = key; this.val = val; this.n = N; this.color = color; public Key getkey() { return key; public void setkey(key key) { this.key = key; public Value getval() { return val; public void setval(value val) { this.val = val; public Node<Key, Value> getleft() { return left; public void setleft(node<key, Value> left) { this.left = left; public Node<Key, Value> getright() { return right; public void setright(node<key, Value> right) { this.right = right; public int getn() { return N; 60

67 public void setn(int n) { N = n; public boolean getcolor() { return color; public void setcolor(boolean color) { this.color = color; Ovaj čitav čvor (Node) osnovni je model za crveno crno binarno stablo pretraživanja. Kada se kreira objekt parametrizirane klase, definira se tip Key i Value. Ova klasa može biti neovisna o tipu podatka jer će funkcionirati bez obzira dobije li int, string, double... Key je tipa string, a polje val je tipa int. Left i right su djeca trenutnog čvora u stablu. Klikom na tražilicu otvara nam se tipkovnica kojom upisujemo riječ, pojam ili brojke koje tražimo (String). No, prije pretrage potrebno nam je filterom odrediti što ćemo pretraživati i po kojem kriteriju, hoće li to biti po cijeni (satnici), nazivu tvrtke, opisu, lokaciji, kategoriji ili datumu. Pretraživanje se pokreće pritiskom na gumb Apply filter (slika 31). 61

68 Slika 31: Odabir kriterija pretrage (filtriranje) Slika 32: Odabir kriterija za pretragu 62

69 Bočni ekran s obabirom kriterija, odnosno s filterom, uskače slijeva preko gotovo čitavog ekrana. Nakon odabranog kriterija (slika 32) po kojem je pretraga filtrirana (kako bi se algoritmu dodatno olakšala pretraga), klikne se Apply Filter. Quick sort napisan je sljedećim kodom: package hr.firma.sp.studentskiposao.algorithm; import java.util.collections; import java.util.list; import hr.firma.sp.studentskiposao.model.abstractdata; public class QuickSort { public static String fieldname; public QuickSort(String fieldname) { QuickSort.fieldName = fieldname; public static void sort(list<abstractdata> a, String fieldname) { QuickSort.fieldName = fieldname; Collections.shuffle(a); sort(a, 0, a.size() - 1); private static void sort(list<abstractdata> a, int lo, int hi) { if (hi <= lo) return; int j = partition(a,lo, hi); sort(a, lo, j - 1); sort(a, j+1, hi); private static int partition(list<abstractdata> a, int lo, int hi) { int i = lo, j = hi + 1; AbstractData v = a.get(lo); while (true) { 63

70 while (less(a.get(++i), v)) if (i == hi) break; while (less(v, a.get(--j))) if (j == lo) break; if (i >= j) break; exch(a, i, j); exch(a, lo, j); return j; private static boolean less(abstractdata v, AbstractData w) { return v.compareto(w, QuickSort.fieldName) < 0; private static void exch(list<abstractdata> a, int i, int j) { AbstractData item = a.get(i); a.set(i, a.get(j)); a.set(j, item); Naredba String fieldname označava polje po kojem se niz sortira te koje je nužno imati zbog pronalaska posla ili tvrtke. Umjesto uspoređivanja polja tipa Comparable[], u ovom slučaju nalazi se lista List<AbstractData> tipova podataka AbstractData koja je roditelj prema JobData i CompanyData (klase modeli za aplikaciju gdje se nalaze nazivi tvrtki i podaci o njima, oni nasljeđuju AbstractData koja je abstraktna klasa ne može imati objekte). Obje navedene klase moraju imati metodu compareto() koja je definirana u AbstractData. 64

71 Slika 33: Pretraživanje posla po kriteriju: tvrtke Kada se upiše riječ Polleo u tražilicu (slika 33), tražilica odmah sortira odabir i sve poslove koje je objavio Polleo. Pretraživanje je obavljeno sljedećim kodom: package hr.firma.sp.studentskiposao.algorithm; public class RedBlackBST<Key extends Comparable<Key>, Value> { private static final boolean RED = true; private static final boolean BLACK = false; private Node<Key, Value> root; private boolean isred(node<key, Value> h) { if (h == null) return false; return h.getcolor() == RED; 65

72 private Node<Key, Value> rotateleft(node<key, Value> h) { Node<Key, Value> x = h.getright(); h.setright(x.getleft()); x.setleft(h); x.setcolor(h.getcolor()); h.setcolor(red); x.setn(h.getn()); h.setn(1 + size(h.getleft()) + size(h.getright())); return x; private Node<Key, Value> rotateright(node<key, Value> h) { Node<Key, Value> x = h.getleft(); h.setleft(x.getright()); x.setright(h); x.setcolor(h.getcolor()); h.setcolor(red); x.setn(h.getn()); h.setn(1 + size(h.getleft()) + size(h.getright())); return x; private void flipcolors(node<key, Value> h) { h.setcolor(red); h.getleft().setcolor(black); h.getright().setcolor(black); private int size(node<key, Value> x) { if (x == null) return 0; else return x.getn(); private Node<Key, Value> put(node<key, Value> h, Key key, Value val) { 66

73 if (h == null) return new Node(key, val, 1, RED); int cmp = key.compareto(h.getkey()); if (cmp < 0) h.setleft(put(h.getleft(), key, val)); else if (cmp > 0) h.setright(put(h.getright(), key, val)); else h.setval(val); if (isred(h.getright()) &&!isred(h.getleft())) h = rotateleft(h); if (isred(h.getleft()) && isred(h.getleft().getleft())) h = rotateright(h); if (isred(h.getleft()) && isred(h.getright())) flipcolors(h); h.setn(size(h.getleft()) + size(h.getright()) + 1); return h; private Value get(node<key, Value> h, Key key) { if (h == null) return null; int cmp = key.compareto(h.getkey()); if (cmp < 0) return get(h.getleft(), key); else if (cmp > 0) return get(h.getright(), key); else return h.getval(); public int size() { return size(root); public void put(key key, Value val) { root = put(root, key, val); root.setcolor(red); public Value get(key key) { return get(root, key); 67

74 Key i Value zadaju se prilikom kreiranja objekta RedBlackBST. Klikom na jedan od kvadrata na početnom ekranu, otvara se veći ekran s mogučnošću prijave na posao (slika 34). Slika 34: Ekran koji se pojavi klikom na tvrtku/posao 68