vizualizacija algoritama sortiranja -...
TRANSCRIPT
SVEUČILIŠTE U ZAGREBU
FAKULTET ORGANIZACIJE I INFORMATIKE
V A R A Ţ D I N
Ivan Reif
VIZUALIZACIJA ALGORITAMA SORTIRANJA
ZAVRŠNI RAD
Varaţdin, 2011.
SVEUČILIŠTE U ZAGREBU
FAKULTET ORGANIZACIJE I INFORMATIKE
V A R A Ţ D I N
Ivan Reif
Redoviti student
Broj indeksa: 37119/2008.
Smjer: Poslovni sustavi
Preddiplomski studij
VIZUALIZACIJA ALGORITAMA SORTIRANJA
ZAVRŠNI RAD
Mentor:
Tihomir Orehovački, mag. inf.
Varaţdin, lipanj 2011.
I
Sadrţaj
1. Uvod ............................................................................................................................................ 1
2. Algoritmi sortiranja ..................................................................................................................... 2
2.1 Mjehurićasto sortiranje .......................................................................................................... 2
2.1.1 Problem zečeva i kornjača .............................................................................................. 4
2.2 Koktel sortiranje .................................................................................................................... 6
2.3 Sortiranje odabirom ............................................................................................................... 9
2.4 Sortiranje umetanjem .......................................................................................................... 11
2.5 Višestruko sortiranje umetanjem ......................................................................................... 13
2.6 Sortiranje češljanjem ........................................................................................................... 16
2.7 Sortiranje pomoću hrpe ....................................................................................................... 19
2.8 Brzo sortiranje ..................................................................................................................... 26
2.8.1 Problem malih polja ..................................................................................................... 29
2.8.2 Analiza slučajeva .......................................................................................................... 29
2.8.3 Odabir stožera ............................................................................................................. 32
3. Programsko rješenje .................................................................................................................. 33
3.1 Opis programskog sustava .................................................................................................. 33
3.2 Analiza programskog koda .................................................................................................. 43
3.2.1 Forma Mdi_forma ................................................................................................... 45
3.2.2 Forma priprema ....................................................................................................... 46
3.2.3 Forma main ............................................................................................................. 48
3.2.4 Forma priprema2 ..................................................................................................... 54
3.2.5 Forma test ................................................................................................................ 55
3.2.6 Forma info ............................................................................................................... 57
3.3 Usporedba programskog rješenja sa sličnim alatima .......................................................... 58
4. Zaključak ................................................................................................................................... 62
Zahvala .......................................................................................................................................... 63
Literatura ....................................................................................................................................... 63
1
1. Uvod
Kada radimo sa velikom količinom podataka važno je da su sortirani jer takav ustroj olakšava
njihovo pretraživanjem. Iz tog razloga je sortiranje uvelike prisutno u informatici, a i u drugim
područjima. Podaci su sortirani u telefonskim imenicima, poreznim registrima, knjižnicama,
skladištima odnosno svugdje gdje je potrebno podatke pretražiti i dohvatiti. Postoji mnogo
algoritama za sortiranje i meĎusobno su vrlo različiti. Ovaj rad prikazuje nekoliko rješenja
problema sortiranja podataka u jednodimenzionalnom polju (nizu) elemenata. U znanosti je
problem sortiranja aktualan te se konstantno istražuju mogućnosti ubrzanja postojećih
algoritama. Nedavno je konstruiran novi algoritam nazvan „intro-sort“ [Musser D, 1997, str. 27]
koji je kombinacija dvaju već poznatih algoritama za sortiranje, a sam je brži od svakog
pojedinačno. U najnižu klasu spadaju najjednostavniji, ali i najsporiji algoritmi kao što su to
mjehurićasto sortiranje (eng. bubble sort) i sortiranje odabirom (eng. selection sort), dok u
najvišu klasu spadaju algoritmi poput brzog sortiranja (eng. quick sort) i sortiranja pomoću hrpe
(eng. heap sort). Cilj teorijskog djela ovog rada je pokazati na razlike izmeĎu ovih algoritama.
Kod navedenih algoritama ulazni parametar je isti – niz id elemenata, a problem je sortirati
elemente niza uzlazno. Svi algoritmi obraĎeni u ovom radu takoĎer su i implementirani pomoću
programskog jezika VB.NET kako bi se demonstrirao postupak samog sortiranja te čitateljima
koji su manje upoznati s radom algoritama pobliže objasnio rad svakog od njih. Vizualizacija
algoritama primjerena je za studente koji su već upoznati sa osnovama programiranja i žele lakše
naučiti korake kroz koje prolaze algoritmi kako bi došli do konačnog rješenja. „Ljudi su vizualna
bića, te imaju tendenciju donositi zaključke na temelju onog što vide“ [Jörg R, 2005, str. 16]. U
navedenoj knjizi autor takoĎer naglašava važnost vizualizacije podataka odnosno vizualizaciju
podataka kao metodu pamćenja. Naime, algoritmi samo opisani riječima studentima koji teže
razmišljaju apstraktno ili nisu dovoljno dobro educirani o programiranju mogli bi predstavljati
velik problem kod učenja. U radu skupine autora [Radošević D i sur., 2009, str. 49] opisan je isti
problem straha, nedovoljnog znanja ili stava prema programiranju te se predlažu manji programi
dizajnirani za specifična područja programiranja koji bi studentima olakšavali učenje. U istom
radu opisan je rad dvaju popularnih programa za edukaciju programiranja. Oba programa rade na
sličnom principu kao i program razvijen za potrebe ovog rada. Primjerice, program „Guido vod
Robot“ radi na način da za unesene korake program izvodi akcije prikazane pomoću točaka i
trokutastog objekta, dok program „Alice“ izvodi složeniju vizualizaciju programskih struktura
pomoću 3D animacije. U usporedbi tih dvaju programa sa programom razvijenim za potrebe
ovog rada može se primijetiti da sadrže iste ili slične komponente kao što su mogućnost
2
interakcije korisnika sa programom na način da se mijenja broj elemenata, način izvoĎenja pa
čak i potpuna kontrola nad ulaznim podacima.
2. Algoritmi sortiranja
2.1 Mjehurićasto sortiranje
Mjehurićasto sortiranje je jednostavan algoritam za sortiranje zasnovan na zamjeni susjednih
elemenata. Radi na principu ponavljanja prolaska kroz niz koji se sortira, usporedbe susjednih
članova i zamjene mjesta ako su pogrešno poredani. Prolasci kroz niz se ponavljaju dok više nije
potrebno vršiti zamjenu. Efikasan je samo za relativno maleni broj elemenata koji se sortiraju, a
za veći broj elemenata metoda je prespora. [Astrachan O, 2003, str.2]
Prvi prolaz: 19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 5 33 45 13 26 10
19 5 33 45 13 26 10
19 5 33 13 45 26 10
19 5 33 13 26 45 10
19 5 33 13 26 10 | 45
Drugi prolaz: 19 5 33 13 26 10 | 45
5 19 33 13 26 10 | 45
5 19 33 13 26 10 | 45
5 19 13 33 26 10 | 45
5 19 13 26 33 10 | 45
5 19 13 26 10 | 33 45
Treći prolaz: 5 19 13 26 10 | 33 45
5 19 13 26 10 | 33 45
5 13 19 26 10 | 33 45
5 13 19 26 10 | 33 45
5 13 19 10 | 26 33 45
Četvrti prolaz: 5 13 19 10 | 26 33 45
5 13 19 10 | 26 33 45
5 13 19 10 | 26 33 45
5 13 10 | 19 26 33 45
3
Peti prolaz: 5 13 10 | 19 26 33 45
5 13 10 | 19 26 33 45
5 10 | 13 19 26 33 45
Šesti prolaz: 5 10 | 13 19 26 33 45
5 | 10 13 19 26 33 45
Slika 2.1. Primjer mjehurićastog sortiranja
Algoritam se izvodi u više koraka. U prvom koraku usporeĎuju se susjedni članovi liste s
pomakom od jednog elementa odnosno član (n) i (n+1). Ukoliko elementi ne zadovoljavaju uvjet
oni zamjenjuju mjesta. Kad se prolazom doĎe do kraja liste, element koji se nalazi na kraju ima
najveću vrijednost u listi te se on „uklanja“ iz nesortiranog dijela liste i veličina liste koja se
treba sortirati se smanjuje za jedan element. Nakon toga algoritam se prebacuje na početak liste i
operacije se izvode ponovno. Slikom 2.1. prikazano je sortiranje liste pomoću mjehurićastog
sortiranja. Potrebno je napomenuti da se svakim prolazom algoritma kroz nesortirani dio liste
obavezno dobiva jedan element koji se pridodaje sortiranom dijelu liste, te da je takvo izvoĎenje
vremenski definirano linearno. Algoritam 2.1. je implementacija mjehurićastog sortiranja u
programskom jeziku Visual Basic.net sa označenim mjestima na kojima se izvodi usporedba
elementa (i) i elementa (i+1) odnosno susjednih elemenata.
Public Sub bubble_sort(ByVal array() As Integer) Dim i As Long Dim iMin As Long Dim iMax As Long Dim varSwap As Object Dim blnSwapped As Boolean iMin = LBound(Array) iMax = UBound(Array) - 1 Do blnSwapped = False For i = iMin To iMax If Array(i) > Array(i + 1) Then '<- usporedba varSwap = Array(i) '<- zamjena Array(i) = Array(i + 1) Array(i + 1) = varSwap blnSwapped = True End If Next iMax = iMax - 1 Loop Until Not blnSwapped End Sub
Algoritam 2.1. Implementacija mjehurićastog sortiranja u vb.net -u
4
Kako bi se odredila efikasnost algoritama sortiranja često se usporeĎuje broj usporedbi, broj
zamjena i memorija koja im je potrebna za izvoĎenje. Kako algoritmi obraĎeni u ovom radu ne
zahtijevaju dodanu memoriju odnosno zauzimaju samo prostor koji je potreban za spremanje
polja koje se sortira, algoritme možemo usporeĎivati samo po broju zamjena ili broju usporedba
koje izvršavaju tijekom izvoĎenja. Analiza vremenske složenosti mjehurićastog sortiranja može
se iskazati sljedećim izračunom.
Najprije treba definirati najgori i najbolji slučaj za mjehurićasto sortiranje. Najgori slučaj bio bi
potpuno nesortirano polje odnosno sortirano silazno, u kojem slučaju bi se svaki put morala
izvoditi i usporedba i zamjena elemenata. Najbolji slučaj bi s druge strane bio već sortirano bolje
i u tom slučaju obavit će se samo jedan prolaz s usporedbi i 0 zamjena.
U prvom prolazu u najgorem slučaju imamo usporedbi i zamjena elemenata.
U drugom prolazu u najgorem slučaju imamo usporedbi i zamjena elemenata.
Prema tome ukupan broj operacija u najgorem slučaju iznosio bi:
( ) ( ) ( )
( )
Za bilo koje drugo ureĎenje početnog polja broj operacija bio prema tome izmeĎu idealnog i
najgoreg slučaja odnosno izmeĎu i ( ). U svakom slučaju, vrijeme izvoĎenja bilo
bi ( ). [Marušić M, 2007, str. 54].
2.1.1 Problem zečeva i kornjača
Jedan od glavnih problema mjehurićastog sortiranja je da vrijeme izvoĎenja algoritma uvelike
ovisi o početnom rasporedu elemenata u listi. Elementi koji imaju veliku vrijednost (zečevi)
prolaze listom jako brzo, dok malo vrijednosti (kornjače) idu prema dolje vrlo sporo. [Canaan C i
sur., 2011, str. 43]. Na slici 2.2. „kornjaču“ predstavlja element vrijednosti 1, treba primijetiti da
je broj 1 najmanja vrijednost ove nesortirane liste i da se nalazi na kraju liste. Taj element se
5
usporeĎuje i mijenja mjesta sa elementima veće vrijednosti svakim prolazom algoritma kroz
listu
Prvi prolaz: 2 3 4 5 1
2 3 4 5 1
2 3 4 5 1
2 3 4 5 1
2 3 4 1 | 5
Drugi prolaz: 2 3 4 1 | 5
2 3 4 1 | 5
2 3 4 1 | 5
2 3 1| 4 5
Treći prolaz: 2 3 1| 4 5
2 3 1| 4 5
2 1 | 3 4 5
Četvrti prolaz: 2 1 | 3 4 5
1 | 2 3 4 5
Slika 2.2. Problem kornjača mjehurićastog sortiranja
Za razliku od elemenata nazvanih „kornjače“, elementi „zečevi“ se mogu pomaknuti na kraj liste
vrlo brzo, a ako je odabrani element ima najveću vrijednost u listi on se pomakne na kraj liste u
samo jednom prolazu algoritma kao što je prikazano na slici 2.3.
Prvi prolaz: 6 1 2 3 4 5
1 6 2 3 4 5
1 2 6 3 4 5
1 2 3 6 4 5
1 2 3 4 6 5
1 2 3 4 5 | 6
6
Drugi prolaz: 1 2 3 4 5 | 6
1 2 3 4 5 | 6
1 2 3 4 5 | 6
1 2 3 4 5 | 6
Slika 2.3. Problem zečeva mjehurićastog sortiranja
2.2 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 polja 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 polja „lijevo – desno“ čime se dobiva iluzija miješanja koktela.
Koktel sortiranjem se uklanjaju problemi kornjača iz mjehurićastog sortiranja jer se manje
vrijednosti pomiču u lijevo pri prolasku algoritma sa desne strane prema početku liste odnosno
na lijevu stranu. Ovaj algoritam sortiranja spomenut je i u radu [Knuth D, 1998, str. 110], u
kojem autor izražava zabrinutost da ni jedna od ovih modifikacija mjehurićastog sortiranja ne
vode boljem rješenju od sortiranja umetanjem, a da sortiranje umetanjem nije pogodno za velike
liste-
Prvi prolaz: 19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 5 33 45 13 26 10
19 5 33 45 13 26 10
19 5 33 13 45 26 10
19 5 33 13 26 45 10
19 5 33 13 26 10 | 45
Drugi prolaz: 19 5 33 13 26 10 | 45
19 5 33 13 10 26 | 45
19 5 33 10 13 26 | 45
19 5 10 33 13 26 | 45
19 5 10 33 13 26 | 45
7
5 19 10 33 13 26 | 45
Treći prolaz: 5 19 10 33 13 26 | 45
5 19 10 33 13 26 | 45
5 10 19 33 13 26 | 45
5 10 19 33 13 26 | 45
5 10 19 13 33 26 | 45
5 10 19 13 26 | 33 45
Četvrti prolaz: 5 10 19 13 26 | 33 45
5 10 19 13 26 | 33 45
5 10 13 19 26 | 33 45
5 10 13 19 26 | 33 45
5 10 13 19 26 | 33 45
Slika 2.4. Primjer koktel sortiranja
Na primjeru koktel sortiranja prikazanom na slici 2.4 algoritmu je trebalo manje prolaza kroz
polje nego mjehurićastom sortiranju da bi se polje sortiralo jer su se istovremeno pomicale i
manje vrijednosti prema lijevoj strani.
Public Sub cocktail_sort(ByVal array() As Integer) Dim i As Long Dim iMin As Long Dim iMax As Long Dim varSwap As Object Dim blnSwapped As Boolean iMin = LBound(array) iMax = UBound(array) - 1 Do blnSwapped = False For i = iMin To iMax If array(i) > array(i + 1) Then '<- usporedba varSwap = array(i) '<- zamjena array(i) = array(i + 1) array(i + 1) = varSwap blnSwapped = True End If Next iMax = iMax - 1 If Not blnSwapped Then Exit Do For i = iMax To iMin Step -1 If array(i) > array(i + 1) Then '<- usporedba varSwap = array(i) '<- zamjena array(i) = array(i + 1) array(i + 1) = varSwap blnSwapped = True End If Next
8
iMin = iMin + 1 Loop Until Not blnSwapped End Sub
Algoritam 2.2. Implementacija koktel sortiranja u vb.net -u
Algoritmom 2.2. prikazano je koktel sortiranje implementirano pomoću jezika Visual Basic.net i
iz prikazanog bi se trebalo vidjeti da se implementacija sastoji od dva dijela odnosno dvije for
petlje koja izvode istu akciju usporedbe i zamjene kao što se to radi i u mjehurićastom sortiranju
no u ovom slučaju prva petlja je izvorno mjehurićasto sortiranje, dok se druga petlja izvodi pri
povratku algoritma s desne strane na lijevu što je karakteristika koktel sortiranja. Te dvije petlje
se izvode naizmjenično i time se dobiva prolazak mjehurićastog sortiranja u oba smjera.
Analiza vremenske složenosti koktel sortiranja može se iskazati sljedećim izračunom. Pošto je
koktel sortiranje samo modifikacija mjehurićastog sortiranja, on dijeli i njegovu vremensku
složenost, njegov najgori slučaj bi isto tako bilo polje sortirano potpuno silazno, jer bi algoritam
prolazeći u oba smjera morao provesti iste akcije koje bi provelo i mjehurićasto sortiranje.
Najbolji slučaj bi s druge strane bio već sortirano polje i u tom slučaju obavit će se samo jedan
prolaz s usporedbi i 0 zamjena.
U prvom prolazu algoritma petljom prema desno u najgorem slučaju imamo usporedbi i
zamjena elemenata.
U drugom prolazu algoritam se vraća u lijevo pa se izvodi usporedbi i zamjena
elemenata.
Prema tome ukupan broj operacija u najgorem slučaju iznosio bi:
( ) ( ) ( )
( )
Za bilo koje drugo ureĎenje početnog polja broj operacija bio prema tome izmeĎu idealnog i
najgoreg slučaja odnosno izmeĎu i ( ). U svakom slučaju, vrijeme izvoĎenja bilo
bi ( ).
9
2.3 Sortiranje odabirom
Sortiranje odabirom spada u skupinu „in-place“ algoritama sortiranja što znači da takav
algoritam ne zahtjeva dodatni pomoćni prostor za pospremanje elemenata koji se sortiraju. On
koristi originalni prostor zauzet sa skupom podataka koji se sortiraju i nakon zamjene elementi
se nalaze na svojem konačnom mjestu. [Slamić M, 2011, str. 3]. Postupak sortiranja izvodi se na
način da se traži najmanji element u nizu i zamijeni ga se sa prvim elementom niza. Zatim se
traži drugi najmanji elementi i zamijeni ga se sa drugim elementom niza itd.
Prvi prolaz: 19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 33 5 45 13 26 10
5 33 19 45 13 26 10
Drugi prolaz: 5 33 19 45 13 26 10
5 33 19 45 13 26 10
5 33 19 45 13 26 10
5 33 19 45 13 26 10
5 33 19 45 13 26 10
5 10 19 45 13 26 33
Treći prolaz: 5 10 19 45 13 26 33
5 10 19 45 13 26 33
5 10 19 45 13 26 33
5 10 19 45 13 26 33
5 10 13 45 19 26 33
Četvrti prolaz: 5 10 13 45 19 26 33
5 10 13 45 19 26 33
5 10 13 45 19 26 33
5 10 13 19 45 26 33
Peti prolaz: 5 10 13 19 45 26 33
5 10 13 19 45 26 33
5 10 13 19 26 45 33
Šesti prolaz: 5 10 13 19 26 45 33
5 10 13 19 26 33 45
Slika 2.5. Primjer sortiranja odabirom
10
Kod sortiranja odabirom nakon svakog prolaza algoritma nizom uvijek se izvodi samo jedna
zamjena elemenata. Elementi koji zamjenjuju mjesta su element koji je ima najmanju vrijednost
u nesortiranom dijelu liste i prvi element u nesortiranom djelu liste, odnosno element koji slijedi
nakon zadnjeg elementa sortiranog djela liste. Na slici 2.5 prikazan je postupak takve zamjene
elemenata. Kako bi se pronašao najmanji element u nesortiranom djelu liste algoritam
usporeĎuje trenutni element sa sljedećim, ukoliko je sljedeći element manji od trenutnog
elementa, taj element postaje najmanji te se dalje usporeĎuje sa sljedećim.
Public Sub selection_sort(ByVal array() As Integer) Dim cnt1 As Long Dim cnt2 As Long Dim nMin As Long Dim tmp As Long Dim counter As Long For cnt1 = LBound(array) To UBound(array) - 1 nMin = cnt1 For cnt2 = (cnt1 + 1) To UBound(array) If array(cnt2) < array(nMin) Then '<- usporedba nMin = cnt2 counter = counter + 1 End If Next cnt2 tmp = array(nMin) '<- zamjena array(nMin) = array(cnt1) array(cnt1) = tmp Next cnt1 End Sub
Algoritam 2.3. Implementacija sortiranja odabirom u vb.net –u
Implementacija navedenog algoritma sastoji se od dva važna dijela. Prvi dio odnosi se na
usporedbu elemenata unutar niza kojom se dobiva element sa najmanjom vrijednošću zapisan u
varijabli nMin,nakon što je algoritam usporedbom došao do kraja niza i najmanji element
zamjenjuje poziciju sa prvim elementom u nesortiranom djelu liste. Algoritmom 2.3. prikazane
su funkcije usporedbe unutar for petlje koja prolazi cijelim poljem te jednostavna zamjena
elemenata na izlasku iz petlje.
11
ProvoĎenje analize vremenske složenosti sortiranja odabirom je jednostavnije u odnosu na ostale
algoritme sortiranja zbog toga jer ni jedna od petlji ne ovisi o podacima u polju. Odabir
najmanjeg elementa zahtjeva pregledavanje svih n elemenata ( usporedbi ) te se zatim
zamjenjuju elementi na prvu poziciju nesortiranog djela polja. Pronalazak sljedećeg najmanjeg
elemenata isto tako zahtjeva pregledavanje ostatka elmenata. Takav postupak traženja
najmanjeg elemenata može se zapisati aritmetičkim nizom poput
( ) ( )
Konačan rezultat vremenske složenosti opisan je sa ( ) zbog ( ) usporedbi.
2.4 Sortiranje umetanjem
Sortiranje umetanjem je algoritam koji se svodi na umetanje novog elementa u već sortirani niz
elemenata. Dok algoritam prolazi poljem, polje se dijeli na dva dijela, na početni ili sortirani dio
i 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.
Početno polje: 19 | 33 5 45 13 26 10
Nakon 1. prolaska: 19 33 | 5 45 13 26 10
Nakon 2. prolaska: 5 19 33 | 45 13 26 10
Nakon 3. prolaska: 5 19 33 45 | 13 26 10
Nakon 4. prolaska: 5 13 19 33 45 | 26 10
12
Nakon 5. prolaska: 5 13 16 26 33 45 | 10
Nakon 6. prolaska: 5 10 13 16 26 33 45 |
Slika 2.6. Primjer sortiranja umetanjem
Slika 2.6 prikazuje polje koje se sortira umetanjem, stanje tog polja je prikazano nakon svakog
prolaska algoritma. Isto tako element koji se prenosi u sortirani dio liste prikazan je sivom
bojom, a lokacija na koju se prenosi označena je strelicom.
Public Sub insertion_sort(ByVal array() As Integer) Dim i As Long Dim j As Long Dim iMin As Long Dim iMax As Long Dim varSwap As Object iMin = LBound(array) + 1 iMax = UBound(array) For i = iMin To iMax varSwap = array(i) For j = i To iMin Step -1 If varSwap < array(j - 1) Then '<- usporedba array(j) = array(j - 1) '<- zamjena Else Exit For Next j array(j) = varSwap Next i End Sub
Algoritam 2.4. Implementacija sortiranja umetanjem
Algoritam 2.4. prikazuje kako je implementacija sortiranja umetanjem kratka i jednostavna.
Glavni elementi ovog algoritma su varijablom varSwap koja sadrži trenutnu vrijednost
promatranog elementa koji se pomiče u sortirano polje, granice koje odjeljuju sortirani dio od
nesortiranog označene varijablama iMax i iMin, te varijable i i j od kojih varijabla i predstavlja
indeks trenutnog elementa, a varijabla j indeks elementa za koji se vrši usporedba, odnosno
indeks elementa čija vrijednost je sadržana u varijabli varSwap. Vremenska složenost ovog
algoritma je ( ) dobivena sljedećim izračunom.
U -tom prolasku unatrag algoritam prolazi sortirani dio polja duljine . Prenosimo gledani
element i pomičemo elemente u polju za jedno mjesto prema desno tako dugo dok elementi
13
imaju veću vrijednost od promatranog. U najgorem slučaju naš element je najmanji element koji
se prenosi u sortirano polje i treba izvršiti usporedbu i zamjenu sa svakim elementom sortiranog
polja kako bi naš element umetnuli na željenu lokaciju.
Prema tome ukupni broj akcija u najgorem slučaju je
( ) ( )
i rezultira vremenskom složenosti od ( ). Iako je vremenska složenost sortiranja umetanjem
jednaka mjehurićastom sortiranju i koktel sortiranju u praksi ovaj algoritam se pokazuje bržim.
[Marušić M, 2007, str. 57]
2.5 Višestruko sortiranje umetanjem
Višestruko sortiranje umetanjem (eng. Shell sort) je algoritam sortiranja koji je 1959. godine
konstruirao Donald Shell. Višestruko sortiranje umetanjem je generalizacija običnog sortiranja
umetanjem koji 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. Za neki zadani promatra se različitih pod-polja sastavljenih od
elemenata originalnog polja meĎusobno razmaknutih za mjesta. Pod-polja se definiraju kao
[ ] [ ] [ ]
[ ] [ ] [ ]
[ ] [ ] [ ]
Na zadanim poljima izvodi se sortiranje umetanjem koje usporeĎuje elemente koji su odvojeni za
takozvani „inkrement“ koji je razlika indeksa dvaju članova u originalnom polju, a postaju
14
susjedni članovi u pod-polju. Taj inkrement se smanjuje za pola svaki put kada je polje za zadani
inkrement sortirano. Pa prema tome ako nam je početni inkrement 4, on se nakon sortiranja
smanjuje na 2, pa nakon što je i to pod-polje sortirano, smanjuje se na 1, kada se izvodi
originalno sortiranje umetanjem, no onda bi polje trebalo biti već skoro pa sortirano.
Početno polje: 19 33 5 45 13 26 10
pod-polje za i = 4: 19 33 5 45 13 26 10
nakon sortiranja: 13 33 5 45 19 26 10
pod-polje za i = 2: 19 33 5 45 13 26 10
nakon sortiranja: 5 26 10 33 13 45 19
pod polje za i = 1: 5 26 10 33 13 45 19
nakon sortiranja: 5 10 13 19 26 33 45
Slika 2.7. Primjer raspodjele pod-polja
Algoritmom 2.5. prikazana je implementacija višestrukog sortiranja umetanjem može se
primijetiti da je višestruko sortiranje umetanjem nadograĎeno na obično sortiranje umetanjem s
dodatnom varijablom inc koja predstavlja inkrement. Vrijednost varijable inc se na početku
dobiva kroz argument funkcije odnosno varijablom size koji predstavlja veličinu polja koje
trebamo sortirati. Osim toga taj se inkrement dijeli sa 2 kako bi se kako bi se dobio početni
inkrement pa bi tako za npr. polje veličine 8 elemenata početni inkrement bio 4. Isto tako,
funkcija uvjeta if uzima kao vrijednosti usporedbe duljinu polja umanjenu za inkrement.
Izlaskom iz do-while petlje inkrement se ponovno dijeli sa 2 kako bi se stvorila nova pod-polja
sa novim inkrementom.
Public Sub shell_sort(ByVal array() As Integer, ByVal size As Integer) Dim inc As Integer Dim i As Integer Dim j As Integer Dim temp As Integer Dim bUmetni As Boolean inc = size \ 2 While inc > 0 For i = inc To size - 1 temp = array(i) j = i bUmetni = False
15
Do If array(j - inc) > temp Then '<- usporedba array(j) = array(j - inc) '<- zamjena j = j - inc If j < inc Then bUmetni = True Else bUmetni = True End If Loop Until bUmetni array(j) = temp Next inc = inc \ 2 End While End Sub
Algoritam 2.5. Implementacija višestrukog sortiranja umetanjem
„Algoritam višestrukog sortiranja umetanjem (Shell sort) predstavlja nepoznanicu i tvrd orah za
istraživače. Naime, za razliku od drugih algoritama, za taj algoritam još uvijek ne postoje jasne i
cjelovite ocjene vremenske složenosti.“ [Marušić M, 2007, str. 58]. Prema tome mjerenje
vremenske složenosti višestrukog sortiranja umetanjem predstavlja problem zbog odabira
algoritma po kojem se odreĎuje veličina inkrementa pod-polja. Prema tome najgori slučaj
izvoĎenja ovog algoritma je svakako polje koje je sortirano silazno pa se za svaki element
odvija usporedba i zamjena i takva slučaj predstavljen je vremenskom složenošću od ( ) .
Ako se odabire neki od padajućih nizova oblika
tada je složenost u najgorem slučaju ( ) .
Odabir veličine inkrementa uvelike utječe na vremensku složenost algoritma kao što se može
vidjeti na sljedećim primjerima.
Shell-ov inkrement (
) → ( )
Hibbard-ov inkrement ( ) → ( )
Sedgewick-ov inkrement ( ) → ( )
Pratt-ov inkrement ( ) → ( )
16
2.6 Sortiranje češljanjem
Sortiranje češljanjem (eng. comb sort ) je algoritam sortiranja kojeg je 1980. godine konstruirano
Wlodzimierz Dobosiewicz , a kasnije je bio ponovno otkriven i populariziran od strane Stephena
Lacey-a u časopisu „Byte Magazine“ izdanom 1991. godine. [Lacey S, 1991, str.16]. 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
već spomenuti 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 iznosi jedan. Ideja primijenjena u sortiranju češljanjem je da taj razmak može biti puno veći
od jedan. Sortiranje češljanjem je takoĎer baziran na toj ideju, no on je modifikacija 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. Faktor sažimanja ima velik
utjecaj na učinkovitost algoritma sortiranja češljanjem. U članku [Lacey S, 1991, str.36]. autor je
naveo 1.3 kao najbolji faktor sažimanja nakon niza provedenih testova i usporedbi. Ako bi
vrijednost faktora bila premala algoritam bi se usporio jer bi se trebalo izvesti više usporedbi, a
kad bi vrijednost bila prevelika ne bi se izvelo dovoljno usporedba. Vrijednost od 1.3 dobivena je
empirijskim testovima sortiranja češljanjem na preko 200,000 nasumično generiranih lista te
prikazan formulom
( )
u kojem slučaju varijabla φ predstavlja vrijednost zlatnog reza. Prema [Huntley H, 1970, str. 22]
zlatni rez je kompozicijski zakon u kojem se manji dio prema većem odnosi kao veći dio prema
ukupnom. To je način podjele neke vrijednosti s faktorom od približno φ = 1.61803399 te je
izračunat izrazom ( √ ) . Jedno zanimljivo poboljšanje ovog algoritma nazvano je „Pravilo
11“ koje se odnosi na veličinu intervala ukoliko bi on iznosio 9 ili 10. Ustanovljeno je ako se
koristi faktor sažimanja od 1.3 na listama, da iznos toga faktora može imati samo tri slučaja kako
se približava kraju.
17
1. slučaj ( 9, 6, 4, 3, 2, 1 )
2. slučaj ( 10, 7, 5, 3, 2, 1 )
3. slučaj ( 11, 8, 6, 3, 2, 1 )
Rezultati eksperimenata prikazanih u radu [Cormen T i sur., 2001, str. 38] su pokazali kako se
dogaĎaju znatna poboljšanja u brzini obrade algoritma ako se interval postavi na 11 kada bi inače
bio 9 ili 10 dobiven sažimanjem trenutnog intervala. Isto tako moguće je i koristiti prethodno
definirane tablice koje sadrže intervale koji se koriste svakim prolazom algoritma.
Prvi prolaz: (5) 19 33 5 45 13 26 10
19 33 5 45 13 26 10
19 10 5 45 13 26 33
Drugi prolaz: (3) 19 10 5 45 13 26 33
19 10 5 45 13 26 33
19 10 5 45 13 26 33
19 10 5 45 13 26 33
19 10 5 33 13 26 45
Treći prolaz: (2) 19 10 5 33 13 26 45
5 10 19 33 13 26 45
5 10 19 33 13 26 45
5 10 13 33 19 26 45
5 10 13 26 19 33 45
Četvrti prolaz: (1) 5 10 13 26 19 33 45
5 10 13 26 19 33 45
5 10 13 26 19 33 45
5 10 13 26 19 33 45
5 10 13 19 26 33 45
5 10 13 19 26 33 45
Peti prolaz: (1) 5 10 13 19 26 33 45
5 10 13 19 26 33 45
5 10 13 19 26 33 45
5 10 13 19 26 33 45
5 10 13 19 26 33 45
5 10 13 19 26 33 45
Slika 2.8. Primjer sortiranja češljanjem
18
Slika 2.8. prikazuje sortiranje češljanjem i može se primijetiti da se u prva tri prolaza koristi
korak odnosno interval usporedbe varijabilnih veličina. Za prvi prolaz interval je definiran
podjelom veličine polja koji iznosi 7 elemenata s faktorom sažimanja. Operacija dijeljenja tih
dviju vrijednosti rezultira decimalnim brojem 5.38461. Kako bi se dobio interval koji nam je
potreban da bi se definirao korak usporedbe uzima se cjelobrojna vrijednost te operacije odnosno
5. U prvom prolazu algoritma poljem izvode se samo dvije usporedbe i jedna zamjena zbog
velikog koraka usporedbe. U naredna dva prolaza algoritma poljem, interval se smanjuje na 3
odnosno 2 sve dok se u četvrtom prolazu ne smanji na 1. U tom prolazu izvodi se originalno
mjehurićasto sortiranje te se izvode usporedbe diljem cijelog polja i izvodi samo jedna zamjena.
Treba primijeti iako je polje sortirano nakon četvrtog prolaza, da se po pravilima mjehurićastog
sortiranja mora izvesti još jedan prolaz poljem jer se u prethodnom koraku obavila jedna
zamjena.
Public Sub comb_sort(ByVal array() As Integer) Const ShrinkFactor = 1.3 Dim lngGap As Long Dim i As Long Dim iMin As Long Dim iMax As Long Dim varSwap As Object Dim blnSwapped As Boolean iMin = LBound(array) iMax = UBound(array) lngGap = iMax - iMin + 1 Do If lngGap > 1 Then lngGap = Int(lngGap / ShrinkFactor) If lngGap = 10 Or lngGap = 9 Then lngGap = 11 End If blnSwapped = False For i = iMin To iMax - lngGap If array(i) > array(i + lngGap) Then '<- usporedba varSwap = array(i) '<- zamjena array(i) = array(i + lngGap) array(i + lngGap) = varSwap blnSwapped = True End If Next Loop Until lngGap = 1 And Not blnSwapped End Sub
Algoritam 2.6. Implementacija sortiranja češljanjem
Implementacija sortiranja češljanjem poprilično je jednostavna kao što se može vidjeti u
algoritmu 2.6. implementacija se sastoji od običnog mjehurićastog sortiranja kojem je dodana
mogućnost promijene duljine koraka izmeĎu dvaju elementa koji se usporeĎuju. Kao konstanta
19
na početku je definirana varijabla ShrinkFactor koja predstavlja faktor sažimanja. Funkcijama
LBound i UBound dobivena su donja i gornja granica polja i pridružena varijablama iMin i iMax
kako bi se pomoću njih moglo izračunati početni interval odnosno duljina početnog koraka. Na
početku do-while petlje dodan je i uvjet koji predstavlja pravilo „Pravilo 11“ te ako bi vrijednost
varijable lngGap koja predstavlja duljinu koraka bila 10 ili 9 ona bi se postavila na 11. Slijedi i
For petlja koja izvodi usporedbu i zamjenu promatranog elementa na poziciji ( i ) i elementa
uvećanog za korak na poziciji ( i + lngGap ). Iz razloga što je sortiranje češljanjem poboljšanje
mjehurićastog sortiranja oni i dijele vremensku složenost algoritma odnosno najgori slučaj
sortiranja češljanjem je prikazan složenošću od ( ) iako se nakon već spomenutih provedenih
istraživanja u radu [Cormen T i sur., 2001, str. 38] i rada algoritma u praksi pokazalo da je
realnija složenost ovog algoritma ( ( )) ako je u implementaciju uvedeno i pravilo „Pravilo
11“ čime se opasno približava složenosti brzom sortiranju. Pa se može vidjeti na primjeru polja
od 10.000 elemenata koje se sortira češljanjem na prosječnom računalu izvede se za nekih
0.0042 sec, dok brzom sortiranju treba samo 1.1 puta duže. Zanimljivo je kako jako loš algoritam
poput mjehurićastog sortiranja uz malu modifikaciju može konkurirati jednom od najbržih
algoritama poput brzog sortiranja.
2.7 Sortiranje pomoću hrpe
Sortiranje pomoću hrpe je algoritam sortiranja koji su konstruirali W. Floyd i J. W. J. Williams
1964. godine koristi strukturu podataka nazvanu hrpa (eng. heap) kako bi sortirao polje. Kako bi
se polje sortiralo najprije je potrebno izgraditi hrpu od elemenata koji se nalaze u polju, pa se
prema tome jedan po jedan element redom stavljaju na hrpu. Nakon što se hrpa formira, sa vrha
hrpe se uzima najveća vrijednost i sprema na kraj polja koje se sortira, položaj koji taj element
zauzima u polju 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 polja se smanjuje za jedan, a
sortirani dio povećava za jedan sve tako dugo dok na hrpi ne ostane samo jedan element koji
onda čini polje od jednog elementa i sigurno je sortiran te zauzima prvo mjesto u sortiranom
polju.
20
Hrpa dodaj element zamjena
- 6
6 5
6,5 3
6,5,3 1
6,5,3,1 8
6,5,3,1,8 5,8
6,8,3,1,5 6,8
8,6,3,1,5 7
8,6,3,1,5,7 3,7
8,6,7,1,5,3 2
8,6,7,1,5,3,2 4
8,6,7,1,5,3,2,4 1,4
8,6,7,4,5,3,2,1
Tablica 2.1. Izgradnja hrpe za niz ( 6, 5, 3, 1, 8, 7, 2, 4 )
Tablica 2.1. prikazuje izradu hrpe na način da se najveća vrijednost u hrpi uvijek nalazi na vrhu.
Može se primijetiti da se tijekom dodavanja elemenata hrpa mora pokoravati pravilima strukture
hrpe pa se prema tome privremeno zaustavlja dodavanje novog člana u hrpu ako je potrebno
izvesti modifikacije elemenata unutar hrpe da se održi struktura.
→
→
→
6
6
5
6
5 3
21
→
→
→
→
6
5 3
1
6
5 3
1 80
6
8 3
1 5
0
8
6 3
1 5
0
22
→
→
→
8
6 3
1 5
0
7
8
6 7
1 5
0
3
8
6 7
1 5
0
3 2
23
→
→
Slika 2.9. Prikaz izrade strukture hrpe za niz ( 6, 5, 3, 1, 8, 7, 2, 4 )
Sam algoritam sortiranja izvodi se na način da se hrpa prikazana slikom 2.9 konstantno ažurira
nakon što se s nje izvadi element na prvoj poziciji odnosno element s najvećom vrijednošću i
stavi na kraj u listu s rezultatom.
8
6 7
1 5
0
3 2
4
8
6 7
4 5
0
3 2
1
24
Tablica 2.2. Koraci sortiranja pomoću hrpe
Algoritam sortiranja pomoću hrpe najlakše se implementira pomoću dvije odvojene funkcije.
Prva funkcija prikazana algoritmom 2.7. obavlja posao izrade hrpe i održavanja njezine
Hrpa zamjena
elementa
brisanje
elementa sortirano polje
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, 3 8
7, 6, 3, 4, 5, 1, 2 7, 2 8
2, 6, 3, 4, 5, 1, 7 7 8
2, 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, 8
1 1 2, 3, 4, 5, 6, 7, 8
1,2,3,4,5,6,7,8
25
unutarnje strukture, a druga funkcija prikazana algoritmom 2.8. obavlja zamjenu elemenata s
vrha hrpe u sortirani dio liste.
Private Sub Heap(ByVal array() As Integer, ByVal i As Long, ByVal iMin As Long, ByVal iMax As Long) Dim lngLeaf As Long Dim varSwap As Object Do lngLeaf = i + i - (iMin - 1) Select Case lngLeaf Case Is > iMax : Exit Do Case Is < iMax : If array(lngLeaf + 1) > array(lngLeaf) Then lngLeaf = lngLeaf + 1 End Select
If array(i) > array(lngLeaf) Then Exit Do '<- usporedba varSwap = array(i) '<- zamjena array(i) = array(lngLeaf) array(lngLeaf) = varSwap i = lngLeaf Loop End Sub
Algoritam 2.7. Funkcija Heap
Public Sub heap_sort(ByVal array() As Integer) Dim i As Long Dim iMin As Long Dim iMax As Long Dim varSwap As Object iMin = LBound(array) iMax = UBound(array) For i = (iMax + iMin) \ 2 To iMin Step -1 Heap(array, i, iMin, iMax) Next i For i = iMax To iMin + 1 Step -1 varSwap = array(i) '<- zamjena array(i) = array(iMin) array(iMin) = varSwap Heap(array, iMin, iMin, i - 1) Next i End Sub
Algoritam 2.8. Funkcija heap_sort
Implementacija prikazana na algoritmima 2.7 i 2.8 je vrlo praktična iz razloga što se element
proslijeĎen ( element koji se postavi na vrh hrpe pomoću funkcije Heap ) funkciji heap_sort
samo treba zamijeniti na kraj sortirane liste iz razloga što se na ulazu u funkciju heap_sort
poziva funkcija Heap, a njezin rad se nastavlja tek dok se funkcija Heap izvrši. Analiza
složenosti sortiranja pomoću hrpe se svodi na primjenu operacija ubacivanja elemenata u hrpu i
26
njihovog vaĎenja iz hrpe puta. „Budući da jedno ubacivanje odnosno izbacivanje ima složenost
( ( )), slijedi da je vrijeme u najgorem slučaju za cijelo sortiranje reda ( ( ))“ .
[Marušić M, 2007, str. 67].
2.8 Brzo sortiranje
Brzo sortiranje (eng. quick sort) je rekurzivni algoritam za sortiranje. Rekurzivni algoritam je
algoritam koji poziva samog sebe sve dok se ne postigne odreĎeni uvjet. Osnova ovog algoritma
je da se odabire jedan element u polju koji se naziva stožer (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 kao što je
prikazano slikom 2.15.
Slika 2.10. Raspodjela elemenata pri brzom sortiranju
Nakon razvrstavanja elemenata prema zadanom uvjetu element pod nazivom stožer nalazi se na
mjestu u kojem će se nalaziti i u polju sa rezultatom sortiranja. Sortiranje se dalje izvodi
rekurzivnim sortiranjem lijevog i desnog pod-polja odnosno primjenom brzog sortiranja na ta
pod-polja.
stožer
element <= stožer element >= stožer
27
Slika 2.11. Zamjena elemenata iz dva intervala
Razvrstavanje elemenata s lijeve na desnu stranu odvija se tako da se pomiču pokazivači s lijeve
strane polja na desnu sve tako dugo dok su uvjeti zadovoljeni odnosno da su elementi s lijeve
strane manji od stožera, a elementi s desne strane veći. Ako bi se oba pokazivača zaustavila na 2
elemenata to bi značilo da su naĎena dva elementa koja spadaju na krivu stranu u odnosu na
stožer te oni zamjenjuju mjesta i nastavlja se pomicanje pokazivača diljem polja. Prolaz
pokazivača poljem se završava ukoliko se oni „prekriže“ odnosno oba naĎu na istom elementu.
Proces takvog razvrstavanja elemenata unutar polja prikazan je slikom 2.16.
Početno stanje: 19 | 33 5 45 13 26 10
Pomak pokazivača: 19 | 33 5 45 13 26 10
Pomak pokazivača: 19 | 10 5 45 13 26 33
Pomak pokazivača: 19 | 10 5 45 13 26 33
Pomak pokazivača: 19 | 10 5 13 45 26 33
Stožer: 10 5 13 19 45 26 33
Slika 2.12 Prikaz obrade polja za prvi stoţer
> stožer < stožer
zamjena
28
Public Sub quick(ByVal array() As Integer, ByVal intLow As Integer, ByVal intHigh As Integer) Dim tmpVal As Integer Dim i As Integer, j As Integer Dim x As String i = intLow j = intHigh x = array((i + j) / 2) Do While i <= j Do While array(i) < x i = i + 1 Loop Do While array(j) > x j = j - 1 Loop If i <= j Then tmpVal = array(i) array(i) = array(j) array(j) = tmpVal i = i + 1 j = j - 1 End If Loop If intLow < j Then quick(array, intLow, j) End If If i < intHigh Then quick(array, i, intHigh) End If End Sub
Algoritam 2.9. Implementacija brzog sortiranja u vb.net -u
Glavni elementi implementacije brzog sortiranja prikazanog algoritmom 2.9. su varijable i, j i x.
Varijable i i j predstavljaju pokazivače odnosno sadrže indeks trenutnih elemenata koji se
usporeĎuju u polju te se ovisno o tome da li su veći ili manji postavljaju ispred ili iza stožera.
Varijabla x predstavlja vrijednost stožera, a pozicionira se na polovici polja odnosno na poziciji
indeksa ( ) . Nakon deklaracija varijabli slijede dvije do-while koje se izvode tako dugo
dok je vrijednost na indeksu i manja od vrijednosti stožera odnosno vrijednost na indeksu j ako
je veća od vrijednosti stožera. Te dvije do-while petlje izvode akciju prolaska dvaju pokazivača
poljem sve tako dugo dok se ne naĎu na istoj lokaciji, a onda se izvodi umetanje stožera na
odgovarajuće mjesto u polju. Kad se izvede sortiranje i umetanje stožera, rekurzivno se poziva
brzo sortiranje za nesortirane dijelove polje.
29
2.8.1 Problem malih polja
Za jako mala polja veličine manje od 20 elemenata brzo sortiranje ne radi tako dobro kao
sortiranje umetanjem. [Bentley J i McIlory D, 1993, str. 11]. Iz razloga što je brzo sortiranje
rekurzivan algoritam slučajevi sortiranja malih polje dogaĎat će se vrlo često. Kao rješenje
spomenutog problema, predlaže se korištenje algoritma koji ima bolje performanse u sortiranju
polja manjih dimenzija poput sortiranja umetanjem. Još bolji način bio bi da se ostavi polje skoro
pa sortirano i završi sortiranjem umetanjem. Takva strategija bi bila vrlo dobro jer je sortiranje
umetanjem iznimno učinkovito na skoro pa sortiranim poljima, a i uštedjelo bi se oko 15 %
vremena izvoĎenja algoritma.
2.8.2 Analiza slučajeva
Vrijeme izvoĎenja algoritma brzog sortiranja je jednako vremenu izvoĎenja dvaju rekurzivnih
poziva plus linearno vrijeme provedeno na intervalu odnosno pod-polju. Time se dobiva osnovna
formula za brzo sortiranje dana relacijom
( ) ( ) ( )
kao što je opisano u [Weiss M, 1997, str. 263 ]. Vrijednost prikazana izrazom
predstavlja broj elemenata u . Prema tome imamo tri slučaja; najgori, najbolji i prosječni
slučaj. Najgori slučaj dogaĎa se kada je stožer najmanje element pri svakom izboru opisan s
( ) ( )
a svaki sljedeći stožer opisuje se s
( ) ( ) ( )
( ) ( ) ( )
( ) ( ) ( )
Ako sumiramo navedene izraze dobiva se vrijednost koja reprezentira vremensku složenost
brzog sortiranja u najgorem slučaju.
30
( ) ( ) ∑ ( )
U najboljem slučaju element nazvan stožer se nalazi na sredini polja. Kako bi se pojednostavilo
promatranje takvog polja pretpostavimo da su dva pod-polja s lijeve i desne strane stožera
jednake duljine i može se zapisati kao
( ) (
)
pa podijelimo obje strane sa
( )
( )
( )
( )
( )
( )
( )
( )
sada zbrojimo ovih pet jednadžbi, i treba primijetiti da ih ima ( )
( )
( )
( )
te konačni rezultat predstavlja vremensku složenost brzog sortiranja u najboljem slučaju.
( ) ( ) ( ( ))
31
Kod analize prosječnog slučaja pretpostavlja se da svako polje neke duljine ima jednaku
vjerojatnost da se dogodi kao ulaz u algoritam i prema tome se postavlja vjerojatnost izrazom
.
Ako se ova pretpostavka uzme u obzir kod računanja prosječne vrijednost ( ) je ( )
izražen kao
∑ ( )
Ako ovaj izraz uvrstimo u početnu jednadžbu dobivamo
( )
[∑ ( )
]
Treba se maknuti znak za sumu kako bi se pojednostavilo računanje pa prema tome proširujemo
prethodnu jednadžbu
( ) ( ) [∑ ( )
] ( )
te oduzmemo te dvije jednadžbe dobivamo
( ) ( ) ( ) ( )
( ) ( ) ( )
( )
( )
( )
( )
( )
( )
32
( )
( )
Zbrajanjem posljednje četiri jednadžbe dobivamo
( )
( )
∑
Suma ovog izraza je
( )
( ( ))
odnosno pojednostavljeno predstavlja prosječnu vremensku složenost brzog sortiranja
( ) ( ( ))
2.8.3 Odabir stožera
Iako brzo sortiranje radi bez obzira na koji način odabrali stožer očito je da neki slučajevi rade
bolje od drugih. Postoje tri osnovna načina za odabir stožera [Weiss M, 1997, str. 257]. „Krivi
način“, „Sigurno manevriranje“ i „Medijan trojice“. U slučajevima kada se kao stožer odabere
prvi element u polju, riječ je o „krivom načinu“.Takav izbor je prihvatljiv ako je polje popunjeno
nasumičnim vrijednostima, no ako je polje sortirano u suprotnom smjeru odnosno od najvećeg
prema najmanjem onda je takav izbor stožera vrlo loš jer se pri cijepanju polja skoro svi elementi
prenose iz lijevog pod-polja u desno pod-polje i što je najgore isto se dogaĎa i u rekurzivnim
pozivima funkcije. Kod ovakvog odabira stožera se mogao desiti i da je polje već sortirano pa bi
se javljali nepotrebni prolazi poljem i rezultiralo bi vremenskom složenošću od ( ) što je vrlo
sporo i jako povećava prosječnu složenost brzog sortiranja. Alternativa izbora stožera u takvom
slučaju je odabir zadnjeg elementa kao stožer no takav izbor bi bio jednako slab kao i prvi jer bi
se opet moglo desiti da je polje već sortirano u suprotnom poretku. Drugi način za odabir stožera
nazvan je „Sigurno manevriranje“ i provodi se na način da se stožer odabire potpuno nasumično.
Takav odabir stožera je vrlo siguran jer je malo vjerojatno da će se polja loše podijeliti s takvim
33
stožerom. Loša strana ovakvog načina odabira je da unutar algoritma mora postojati funkcija
koja generira nasumični broj kao pivot i moglo bi se desiti da generira loš broj što bi uzrokovalo
pogrešno izvoĎenje algoritma, a i takvo generiranje nasumičnog broja odrazilo bi se i na
vremensku složenost algoritma u cijelosti. Posljednji način odabira stožera naziva se „Medijan
trojice“ i izvodi se na način da se izračunava medijan vrijednosti sadržanih u polju no takva
funkcija bi znatno usporila algoritam pa se izračun stožera izvodi na način da se odaberu tri
nasumične vrijednosti unutar polja i za njih se izračuna medijan. Kada se odaberu tri nasumične
vrijednosti moglo bi se desiti da je odabir vrlo slab i da loše reprezentira medijan cijelog polja pa
se prema tome uzima medijan krajnjih elemenata i srednjeg elementa. Primjerice kod polja
zadanog brojevima ( 4, 2, 1, 5, 6, 7, 8 ), uzele bi se krajnje vrijednosti koje su u ovom slučaju 4 i
8 i srednja vrijednost 5. Unatoč dobro razraĎenom postupku ovakva metoda odabira stožera je
nepredvidiva jer može odabrati vrlo loš stožer.
3. Programsko rješenje
3.1 Opis programskog sustava
Aplikacija je razvijena u programskom paketu Visual Studio 2010 pomoću programskog jezika
Visual Basic. Program se distribuira pomoću Install Shielda integriranog u Visual Studio i pri
instalaciji postavlja na računalo cijelu aplikaciju i sve potrebne komponente za njezin rad kao što
je npr. .net framework 4. Nakon završetka instalacije na radnu površinu računala postavlja se
prečac koji omogućuje brže pokretanje aplikacije. Isto tako prečac se postavlja i u „Program
Files“ kategoriju u startnom izborniku. Nakon pokretanja aplikacije otvara se prva forma
prikazana na slici 3.1.
34
Slika 3.1 Glavni izbornik aplikacije
Prozor aplikacije se pokreče u maksimiziranom obliku kako bi se omogućio što veći prostor za
rad s više vizualizacija istovremeno. Traka sa izbornicima sastoji se od tri padajuća izbornika od
kojih prvi pod nazivom „Algoritmi“ koji sadržava izbor od osam algoritama, a to su;
mjehurićasto sortiranje,koktel sortiranje, sortiranje češljanjem, sortiranje umetanjem, sortiranje
odabirom, sortiranje pomoću hrpe, višestruko sortiranje umetanjem i brzo sortiranje. Drugi po
redu padajući izbornik pod nazivom „Simulacije“ sadržava samo jedan izbor pod nazivom
„Usporedni test“ čijim korištenjem se može točnije analizirati rad algoritama na polju s većim
brojem elemenata. Posljednji izbornik pod nazivom „Info“ sadrži takoĎer samo jedan izbor pod
nazivom „O programu“ koji nakon pokretanja prikazuje formu sa osnovnim informacijama o
programu te autoru i mentoru. Klikom miša na jedan od algoritama prvo se poziva forma
pripreme koja omogućava korisniku da za željeni algoritam postavi početno stanje polja odnosno
ulaza u algoritam i sastoji se od tri dijela kao što je prikazano na slici 3.2
35
Slika 3.2 Priprema početnog stanja polja za ţeljeni algoritam
Forma pripreme početnog stanja polja za algoritam se sastoji od tri djela koji su meĎusobno
povezani uvjetima korištenja pa se prema tome forma prilagoĎava korisniku na način da nakon
što se unese željena veličina polja forma prikazuje polje u dnu forme otkriva padajući izbornik za
odabir metode. Metoda je način popunjavanja polja odabrane veličine i nude se četiri izbora. Prvi
izbor je potpuno nasumično generirano polje koje se i najčešće koristi, nakon toga može se
odabrati unos korisnika čime se korisniku dopušta da unese svoje brojeve u polje. Ako korisnik
odabere takav unos otkriva mu se još jedno polje u koje on mora unijeti točan broj elemenata
koji je definirao u prvom koraku. Svaki broj odnosno element mora biti odvojen znakom za
zarez kako bi program mogao raspoznati granicu meĎu brojevima. Nakon što je korisnik unio
svoje brojeve oni se prenose u prikaz polja gdje korisnik može još jednom vizualno provjeriti da
su to brojevi koje je htio unijeti. Sljedeća dva izbora padajućeg izbornika su skoro sortirano polje
i inverzno generirano polje. Skoro sortirano polje je polje koje je već skoro sortirano no zadnja
dva člana polja su zamijenila mjesta dok se inverzno generirano polje sastoji od nasumično
36
odabranih brojeva i sortiranih silazno što većini algoritama predstavlja najgori slučaj postavke
početnog polja. Za vrijeme kad korisnik unosi brojeve, bira veličinu polja ili metodu
popunjavanja polja gumb „Prihvati“ je onemogućen kako bi se spriječilo pogrešno postavljanje
polja koje bi i rezultiralo pogrešnim radom programa, nakon što je korisnik postavio polje na
željeni način i program je ustanovio da je takvo polje prihvatljivo omogućuje se gumb
„Prihvati“. Nakon pritiska na gumb „Prihvati“ otvara se forma koja vizualizira odabrani
algoritam kao što je prikazano na slici 3.3
Slika 3.3 Prikaz vizualizacije algoritma sortiranja odabirom
Svaka forma sastoji se od nekoliko osnovnih elemenata kao što je označeno bojama na slici 3.3.
Dio označen crvenom pravokutnikom sadržava informacije o vremenskoj složenosti algoritma,
broju usporedbi i broju zamjena koje algoritam izvodi tijekom prolaza kroz polje. Plavim
pravokutnikom označena su dva gumba. Gumb „play“ pokreče animaciju, a gumb „pauze“
zaustavlja odnosno pauzira animaciju. U zelenom pravokutniku nalazi se kontrola kojom se
37
regulira brzina izvoĎenja animacije, ukoliko bi se klizač pomaknuo prema desno animacija bi se
izvodila sporije. U crnom pravokutniku nalaze se „kuglice“ koje reprezentiraju elemente u polju
i sadrže njihove vrijednosti odnosno brojeve. Kuglice koje se usporeĎuju ili zamjenjuju mjesta
postanu zelene. Posljednji element standardne forme je područje ograĎeno sivim pravokutnikom,
a to područje sadržava objašnjenja akcija koje se izvode tijekom animacije. U tom polju nalazi se
i gumb „Dalje“ kojim se animacija može micati korak po korak kako bi se opis koraka mogao
lakše čitati i razumjeti. Kod nekih algoritama nije dovoljno samo prikazati zamjene i usporedbe
koje se izvode kako bi se potpuno pokazalo kako algoritam radi pa je prema tome potrebno bilo
koristiti dodatke ovisno o algoritmu kao što je npr. forma za sortiranje pomoću hrpe prikazana na
slici 3.4.
Slika 3.4 Prikaz vizualizacije algoritma sortiranja pomoću hrpe
Dodatna kontrola koja se koristi u ovoj vizualizaciji je kontrola naziva treeview i u ovom slučaju
služi za prikaz strukture podataka pod nazivom hrpa. Elementi se u takvu strukturu popunjavaju
38
na isti način kao i polje iznad nje te se označuju zelenom bojom pri zamjeni ili usporedbi. U
nekim još složenijim algoritmima poput brzog sortiranja koristi se više nego jedna dodatna
kontrola što je vidljivo na slici 3.4. U ovom slučaju koristi se oznaka intervala odnosno
pravokutnik koji ograĎuje pod-polje koje se trenutno sortira.
Slika 3.5 Prikaz vizualizacije algoritma brzog sortiranja
Još jedna od kontrola je strelica koja se pomiče na mjesto iznad elementa koji je odreĎen kao
stožer. Kod odreĎenih algoritama kao što su to npr. sortiranje pomoću hrpe, sortiranje
umetanjem ili mjehurićasto sortiranje može se tijekom izvoĎenja algoritma znati koji element je
sortiran i ostaje na svojem mjestu do kraja procesa sortiranja. U svrhu vizualizacije tog postupka
koristi se funkcija koja takve elemente oboji u bijelo kao što je to prikazano na slici 3.5.
39
Slika 3.6 Prikaz vizualizacije algoritma sortiranja odabirom
Kako bi se korisniku demonstrirala brzina izvoĎenja pojedinih algoritama sortiranja moguće je i
izvoditi više algoritama istovremeno. Kako bi se korisnicima omogućio potpuni test brzine forma
priprema sadržava vrijednosti koje se posljednje unesene nakon što se otvori nova forma povrh
već jedne koja se izvodi. Takav primjer paralelne izvedbe prikazan je slikom 3.7.
40
Slika 3.7 Paralelno izvoĎenje dviju vizualizacija
U ovom radu u potpunosti su razraĎeni najgori i najbolji slučajevi početne postave i veličine
polja koji se zadaje algoritmu na obradu pa prema tome ograničavanjem polja na samo dvadeset
elemenata algoritmi poput brzog sortiranja ne mogu pokazati svoju punu moć i brzinu obrade
velike količine podataka dok npr. algoritam sortiranja umetanjem ima prednost na malim poljima
a loš je na velikim. Kako bi korisnici imali mogućnost isprobati i u potpunosti usporediti ove
algoritme moramo se vratiti na glavni izbornik i u podajućem izborniku „Simulacije“ izabrati
„Usporedni test“. Takvim izborom opet nam se pojavljuje forma pripreme, no u malo
pojednostavljenoj verziji kao što je vidljivo na slici 3.8.
41
Slika 3.8 Forma pripreme usporednog testa
Iako je ova forma pojednostavljena verzija forme pripreme vizualizacije, ona sadrži funkcije koje
mogu generirati mnogo više elemenata polja i proslijediti ga algoritmu za usporedni test.
Testiranjem forme dolazi se do zaključka da nije preporučljivo unositi više od 50 000 elemenata
na sortiranje jer se dogaĎa da nije moguće podatkom duljine integer prikazati broj usporedbi
koje izvode algoritmi, posebno algoritam mjehurićastog sortiranja jer on izvodi najviše
usporedbi i zamjena. Nakon što je polje generirano pritiskom na gumb „Pokreni test“ otvara se
nova forma koja izvodi svih osam algoritama nad zadanim poljima i vrača nam rezultate testa
kao što je prikazano na slici 3.9.
42
Slika 3.9 Rezultati usporednog testa
Rezultate koje vraća usporedni test prikazani su na način da je svaki algoritam opisan sa dva
faktora kako bi korisnik mogao numerički usporediti broj usporedbi i zamjena koje izvodi
pojedini algoritam, a kako bi se i grafički prikazao rezultat sortiranja pojedinog algoritma forma
prikazuje i graf u kojem je prikazan broj izvedenih usporedbi za svaki algoritam koji se
temeljnim testiranjem pokazao izuzetno točnim u usporedbi sa podacima iz literature. Na kraju
korisniku preostaje još samo jedan izbornik odnosno forma koja prikazuje osnovne informacije o
programu prikazano slikom 3.10.
43
Slika 3.10 Informacije o programu
3.2 Analiza programskog koda
Program je u potpunosti razvijen u programskom paketu Visual Studio.net pomoću programskog
jezika Visual Basic. Program se sastoji od dva osnovna elementa; od forme koja sačinjava
vizualni dio programa i prikazuje rezultate funkcija pomoću kontrola i programskog koda koji
provodi i upravlja tim kontrolama. Program se sastoji od šest osnovnih formi. Forma main koja
sadrži kod koji pokreče vizualizaciju odnosno izvodi upravlja cjelokupnim procesom izvedbe
algoritma te kontrole koje to prikazuju. Forma priprema sadržava funkcije generiranja
nasumičnih brojeva i upravljaju prosljeĎivanjem podataka formi main koja za te postavke izvodi
sortiranje. Forma priprema2 sadržava funkcije slične formi priprema samo bez unosa korisnika i
bez ograničenja na količinu elemenata unutar polja. Forma test sadržava funkcije sortiranja koje
vračaju vrijednost o broju zamjena i usporedbi te funkcija koja prikazuje graf na temelju tih
podataka. Forma info samo sadržava tekst koji opisuje program, te na kraju forma mdi_forma
44
koja je forma tipa mdi1 i sadržava izbornike koji pokreče gore navedene forme. Na slici. 3.11
vidljiv je dijagram klasa u kojem se detaljno vidi sadržaj svake forme odnosno njezine funkcije i
kontrole.
Slika 3.11 Dijagram klasa
1 Mdi forma je forma koja može unutar sebe sadržavati druge forme
45
3.2.1 Forma Mdi_forma
Program 3.1. koji prikazuje isječak koda iz forme pod nazivom Mdi_forma prikazan je prijenos
podataka sa forme na formu „priprema“ na način da se pri ostvarivanju dogaĎaja (eng. event)2
klikom miša na izbornik odnosno jedan od izbora kontrole ToolStrip3 postavlja roditelj forme
priprema na formu Mdi_forma drugim forma priprema će se otvarati unutar forme Mdi_forma te
se na kontrolu label4 tip_sorta pridodaje tekst ovisno o tome koji je algoritam izabran. Iz te
labele forma priprema će pri pokretanju učitati o kojem se sortiranju radi i proslijediti je dalje
formi main.
Public Class Mdi_forma Private Sub BubbleSortToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BubbleSortToolStripMenuItem.Click priprema.MdiParent = Me priprema.Show() tip_sorta.Text = "Bubble Sort" End Sub Private Sub SelectionSortToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SelectionSortToolStripMenuItem.Click priprema.MdiParent = Me priprema.Show() tip_sorta.Text = "Selection Sort" End Sub Private Sub InsertionSortToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles InsertionSortToolStripMenuItem.Click priprema.MdiParent = Me priprema.Show() tip_sorta.Text = "Insertion Sort" End Sub Private Sub ShakerSortToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ShakerSortToolStripMenuItem.Click priprema.MdiParent = Me priprema.Show() tip_sorta.Text = "Cocktail Sort" End Sub Private Sub ShellSortToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ShellSortToolStripMenuItem.Click priprema.MdiParent = Me priprema.Show() tip_sorta.Text = "Shell Sort" End Sub End Class
Program 3.1. Isječak koda iz forme Mdi_forma
2 dogaĎaju vb.net-u opisuje neki dogaĎaj koji pokreče neku akciju
3 ToolStrip je kontorla u vb.net-u koja opisuje traku s izbornikom
4 label je kontrola u vb.net-u koja prikazuje tekst
46
3.2.2 Forma priprema
Forma priprema sastoji se od nekoliko glavnih kontrola, a to su dva textbox-a5, padajući
izbornik, listbox6, panela
7 koje sadržavaju labele sa brojevima i gumb „prihvati“. Pri pokretanju
padajući izbornik, panele i Textbox2 su skriveni, a Listbox je uvijek skriven nije dostupan
korisniku.
Slika 3.12 Prikaz forme priprema u dizajnerskom pogledu
Nakon unosa broja elemenata koji želimo unijeti otvara nam se opcija za izbor metode
popunjavanja tog polja. Te nakon što se promijeni status padajućeg izbornika odnosno odabere
se neka metoda zadan broj panela postaje vidljiv te popunjen odreĎenom metodom.
5 textbox u vb.net-u je kontrola koja omogućuje upis teksta
6 listbox u vb.net-u je kontrola koja omogućuje pohranjivanje lista
7 panela u vb.net-u je kontrola koja omogućava sadržavanje neke druge kontrole unutar sebe
47
Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged ListBox1.Items.Clear() TextBox1.Text = "" If ComboBox1.SelectedIndex = 0 Then Label2.Hide() Label3.Hide() Label26.Hide() Label27.Hide() TextBox1.Hide() Button1.Enabled = True For i As Integer = 0 To TextBox2.Text - 1 ListBox1.Items.Add(RandomClass.Next(1, 100)) Next polja_fill() End If If ComboBox1.SelectedIndex = 1 Then Label2.Show() Label3.Show() TextBox1.Show() Label26.Show() Label27.Show() Button1.Enabled = False End If If ComboBox1.SelectedIndex = 2 Then Label2.Hide() Label3.Hide() Label26.Hide() Label27.Hide() TextBox1.Hide() Dim array(TextBox2.Text) As Integer For i As Integer = 0 To TextBox2.Text - 1 array(i) = RandomClass.Next(1, 100) Next System.Array.Sort(array, 0, CInt(TextBox2.Text - 2)) For i As Integer = 0 To TextBox2.Text - 1 ListBox1.Items.Add(array(i)) Next polja_fill() Button1.Enabled = True End If If ComboBox1.SelectedIndex = 3 Then Label2.Hide() Label3.Hide() Label26.Hide() Label27.Hide() TextBox1.Hide() Dim array(TextBox2.Text) As Integer For i As Integer = 0 To TextBox2.Text - 1 array(i) = RandomClass.Next(1, 100) Next System.Array.Sort(array) System.Array.Reverse(array) For i As Integer = 0 To TextBox2.Text - 1 ListBox1.Items.Add(array(i)) Next polja_fill() Button1.Enabled = True End If End Sub
Program 3.2. Isječak koda iz forme priprema
48
Na isječku prikazanom programom 3.2 vidi se spomenuti dogaĎaj definiran promjenom
vrijednosti u padajućem izborniku te otkrivanju kontrola ovisno o izboru. Funkcija SelectedIndex
dobavlja vrijednost koju ima padajući izbornik na zadanom indeksu. Pa ako se npr. odabere prva
opcija „Random brojevi“ koja se nalazi na indeksu nula pomoću funkcije if izvodi dodavanje
nasumično generiranih brojeva u kontrolu Listbox čiji se podaci dalje prenose u prikaz polja.
Ovisno o odabranom indeksu provode se i ostale akcije poput sortiranja generiranog polja
silazno funkcijom Reverse(array) ili prijenosa korisnikovog unosa u polje.
3.2.3 Forma main
Forma main je osnova glavnog programa i sadrži sve algoritme sortiranja i algoritme animiranja
kontrola. Prema tome kontrole poput TreeView-a, strelice ili pravokutnika koji označuje interval
iako postoje na svakoj formi kada se pokreče algoritam oni postaju vidljivi tek ako je pokrenuti
algoritam koji ih koristi.
49
Slika 3.13 Prikaz forme main u dizajnerskom pogledu
U dizajnerskom pogledu vidljivom na slici 3.13 mogu se vidjeti kontrole koje inače nisu vidljive
korisniku, a koriste se u svrhu animiranja i pokretanju različitih radnji. Osnova izvoĎenja
algoritma animiranja odnosno pomicanja elemenata po formi sastoji se od dva dijela. Prvi dio su
tajmeri (eng. timers)8 koji se pri svakom inkrementu pomiču element. Pa je tako primjerice
Timer1 zadužen za pomicanje kontrole koja sadrži broj prema gore, taj proces se izvodi na način
da se dohvaća pozicija kontrole broja i inkrementira se pomoću tajmera. Tajmer izvodi jednu
akciju povećanja vertikalne pozicije kontrole svakih 0,2 sec i tako se korisniku stvara iluzija da
se element pomiče prema gore. Za izvršenje ukupnog procesa zamjene elemenata potrebna su još
dva tajmera. Timer2 koji dohvaća poziciju elementa s kojim mijenja mjesta te inkrementira
horizontalnu poziciju kontrole i time je pomiče u desno, a Timer3 smanjuje vrijednost vertikalne
pozicije odnosno spušta element natrag u polje. Ovako definirani tajmeri se izvode sekvencijalno
kako bi se osiguralo da se akcije prinosa ne preskaču i dok jedan tajmer radi ostali čekaju njegov
završetak. Pošto su tajmeri vremenski definirani, brzina njihovog izvoĎenja može se kontrolirati
povećanjem ili smanjenjem njihovog inkrementa, pa se prema tome kontrolom TrackBar9 može
animacija usporiti ili ubrzati jer se pomicanjem kliznog pokazivača u desno povećava inkrement
tajmera odnosno tajmer bude izveo akciju manji broj puta unutar jedne sekunde. Drugi važan
osnovni element animacije koji upravlja poretkom kada i koji element zamijeniti je kontrola
ListBox1. Kontrola Listbox1 se popunjava sekvencijalnim akcijama koje izvode algoritmi te se
nakon što je algoritam obradio polje u toj kontroli nalazi popis svih akcija koje je algoritam
izveo i moraju se samo izvesti istim redoslijedom.
Public Sub shell_sort(ByVal array() As Integer, ByVal size As Integer) Dim inc As Integer Dim i As Integer Dim j As Integer Dim temp As Integer Dim bUmetni As Boolean inc = size \ 2 While inc > 0 For i = inc To size - 1 temp = array(i) j = i bUmetni = False Do ListBox1.Items.Add(((j - inc).ToString + "!" + (j).ToString).ToString()) ListBox1.Items.Add(((j - inc).ToString + "|" + (j).ToString).ToString()) If array(j - inc) > temp Then
8 Tajmer u vb.net-u predstavlja kontrolu koja u nekom odreĎenom vremenu izvodi odreĎenu akciju
9 Trackbar u vb.net-u predstavlja kontrolu koja pomicanjem slider-a udesno povećava vrijednost varijable
50
ListBox1.Items.Add(((j).ToString + ">" + (j - inc).ToString).ToString()) array(j) = array(j - inc) j = j - inc If j < inc Then bUmetni = True Else bUmetni = True End If Loop Until bUmetni array(j) = temp Next inc = inc \ 2 End While End Sub
Program 3.3 Isječak koda iz forme main
Na isječku koda prikazanom programom 3.3. prikazano je višestruko sortiranje umetanjem
dopunjeno spomenutom kontrolom ListBox1. Kada bi algoritam pustili da u realnom vremenu
upravlja tajmerima animacija bi se izvela unutar jedne sekunde jer algoritmu treba jako malo
vremena da obradi ovako malo polje pa se prema tome bilježe akcije koje on izvodi, a kasnije se
samo reproduciraju na početnom polju. Kako bi se ispisao taj slijed akcija koji se izvodi pri radu
algoritma svaki put kada se dogaĎa npr. usporedba ili zamjena u ListBox1 se dodaje indeks
elemenata koji su se usporedili ili zamijenili. Točnije kada se izvodi zamjena elementi u
ListBox1 razdvojeni su vertikalnom crtom (npr. „3|4“) kako bi se kasnije iz liste akcija moglo
znati da se radi o usporedbi, pa se tako npr. zamjena označuje kao „3>4“ ili duljina intervala od
jednog do drugog elementa kao „3!4“. Nakon što je algoritam sortiranja završio akcije se moraju
pročitati i izvršiti pomoću animacije, a to se izvodi pomoću funkcije swap prikazane programom
3.4.
Public Sub swap() If j < i Then Dim swap1 As String Dim x, y As Integer swap1 = ListBox1.Items.Item(j) If swap1 Like "*>*" Then Dim pomocno As String() = Nothing pomocno = swap1.Split(">") x = CInt(pomocno(0)) y = CInt(pomocno(1)) TextBox1.Text = y TextBox2.Text = x naziv_pan(y).tag = naziv_pan(y).tabindex
51
naziv_pan(x).tag = naziv_pan(x).tabindex naziv_pan(y).tabindex = x tag_pan() x1 = naziv_pan(TextBox1.Text).top y1 = naziv_pan(TextBox1.Text).left x2 = naziv_pan(TextBox2.Text).top y2 = naziv_pan(TextBox2.Text).left j = j + 1 Timer1.Start() End If
Program 3.4. Isječak koda iz forme main, dio funkcije swap
U ovom isječku prikazano je prepoznavanje zamjene elemenata. Pri pokretanju funkcije dohvaća
se sljedeća akcija iz ListBox1 i uvjetom „if like „*>* “ “ se provjerava da li taj zapis sadržava
znak „>“, ukoliko je to istina prvi element se sprema u varijablu x, a drugi u varijablu y te se
nakon dohvaćanja njihovih pozicija pokreće Timer1 koji sekvencijalno izvrši postupak zamjene
tih elemenata. Svaki tajmer sadržava unutar sebe dogaĎaj Tick, a to je akcija koja se izvodi pri
svakom njegovom inkrementu.
Public Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick Button2.Enabled = False naziv_pan(TextBox1.Text).Controls(2).Shapes().Item(0).FillColor = Color.FromKnownColor(KnownColor.LightGreen) naziv_pan(TextBox2.Text).Controls(2).Shapes().Item(0).FillColor = Color.FromKnownColor(KnownColor.LightGreen) naziv_pan(TextBox1.Text).Controls(1).backcolor = Color.FromKnownColor(KnownColor.LightGreen) naziv_pan(TextBox2.Text).Controls(1).backcolor = Color.FromKnownColor(KnownColor.LightGreen) If TreeView1.Visible = True Then polje_nod(TextBox1.Text).BackColor = Color.FromKnownColor(KnownColor.LightGreen) polje_nod(TextBox2.Text).BackColor = Color.FromKnownColor(KnownColor.LightGreen) End If If Me.Text = "Heap Sort" And nakraj = True Then Label9.Text = "Nakon sto je generirana hrpa za nesortirani dio liste sa najvecom vrijednoscu na vrhu, ta vrijednost ( " + naziv_pan(TextBox2.Text).Controls(1).Text + " ) se prenosi u sortirani dio liste i uklanja iz hrpe." End If If Me.Text = "Heap Sort" And nakraj = False Then Label9.Text = "Kako bi se stvorila struktura Hrpe odnosno dobila najveca vrijednost u polju na vrhu broj " + naziv_pan(TextBox2.Text).Controls(1).Text + " i " + naziv_pan(TextBox1.Text).Controls(1).Text + " zamjenjuju mjesta" End If If naziv_pan(TextBox1.Text).top > 40 Then naziv_pan(TextBox1.Text).top = naziv_pan(TextBox1.Text).top - 10
52
Else Timer1.Stop() Timer2.Start() End If
Program 3.5. Isječak koda iz forme main, Timer1_Tick
Programom 3.5. prikazan je kod koji se izvodi svaki puta kad se Timer1 inkrementira. Na
početku se provodi akcija promjene boje elemenata u zelenu kako bi se označili elementi koji
mijenjaju poziciju, nakon toga se ispituje o kojem se algoritmu sortiranja radi jer se ovisno o
svakom sortiranju prikazuje druga poruka u opisu algoritma. Prema tome ako se npr. radi o
sortiranju pomoću hrpe ispisuje se poruka o akciji koja se izvodi i dohvaćaju se podaci o
elementima nad kojima se provodi akcija zamjene. Na kraju se inkrementira pozicija samog
elementa kako bi se pomaknuo prema gore u položaju relativnom u odnosu na formu te ukoliko
je dosegao granicu do koje se mora pomaknuti pokreče Timer2 koji izvodi horizontalno
pomicanje. Osim ovih triju tajmera koji izvode funkciju zamjene elemenata na formi su prisutna
još tri tajmera. Timer4 zadužen je za prikaz elemenata koji se usporeĎuju odnosno kao što je
prikazano programom 3.6. na početku izvedbe tajmer oboji elemente zelenom bojom isto kao i
pri zamjeni, ispiše poruku ovisno o tipu sortiranja koji se provodi te izvede ovaj isti postupak
četiri puta, kako bi se dobilo zakašnjenje tijekom akcija da korisnik stigne pročitati poruku koja
se ispisuje i stigne vidjeti elemente koji se usporeĎuju. Dodatak ovom tajmeru je upravljanje
TreeView kontrolom koja se koristi u sortiranju pomoću hrpe te takoĎer označuje elemente koji
se usporeĎuju unutar hrpe.
Public Sub Timer4_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer4.Tick k = k + 1 Button2.Enabled = False naziv_pan(TextBox1.Text).Controls(2).Shapes().Item(0).FillColor = Color.FromKnownColor(KnownColor.LightGreen) naziv_pan(TextBox2.Text).Controls(2).Shapes().Item(0).FillColor = Color.FromKnownColor(KnownColor.LightGreen) naziv_pan(TextBox1.Text).Controls(1).backcolor = Color.FromKnownColor(KnownColor.LightGreen) naziv_pan(TextBox2.Text).Controls(1).backcolor = Color.FromKnownColor(KnownColor.LightGreen) If Me.Text = "Heap Sort" Then Label9.Text = "Usporedjuju se vrijednosti unutar Hrpe kako bi se dobila pravilna struktura, usporedjuju se " + naziv_pan(TextBox2.Text).Controls(1).Text + " i " + naziv_pan(TextBox1.Text).Controls(1).Text + "." Else Label9.Text = "Usporedi " + naziv_pan(TextBox2.Text).Controls(1).Text + " i " + naziv_pan(TextBox1.Text).Controls(1).Text + "." End If
53
If TreeView1.Visible = True Then polje_nod(TextBox1.Text).BackColor = Color.FromKnownColor(KnownColor.LightGreen) polje_nod(TextBox2.Text).BackColor = Color.FromKnownColor(KnownColor.LightGreen) End If If k = 4 Then naziv_pan(TextBox1.Text).Controls(2).Shapes().Item(0).FillColor = Color.FromKnownColor(KnownColor.LightSteelBlue) naziv_pan(TextBox2.Text).Controls(2).Shapes().Item(0).FillColor = Color.FromKnownColor(KnownColor.LightSteelBlue) naziv_pan(TextBox1.Text).Controls(1).backcolor = Color.FromKnownColor(KnownColor.LightSteelBlue) naziv_pan(TextBox2.Text).Controls(1).backcolor = Color.FromKnownColor(KnownColor.LightSteelBlue) k = 0 Timer4.Stop() If TreeView1.Visible = True Then polje_nod(TextBox1.Text).BackColor = Color.FromKnownColor(KnownColor.LightSteelBlue) polje_nod(TextBox2.Text).BackColor = Color.FromKnownColor(KnownColor.LightSteelBlue) End If If korak = False Then swap() End If usporedbi.Text = CInt(usporedbi.Text) + 1 Button2.Enabled = True End If End Sub
Program 3.6 Isječak koda iz forme main, Timer4_Tick
Ostala dva tajmera izvode samo akciju usporavanja animacije odnosno Timer5 izvodi
zakašnjenje kako bi se prikazalo pozicioniranje pravokutnika koji označava interval odnosno
pod-polje, a Timer6 izvodi zakašnjenje u prikazu strelice koja npr. u brzom sortiranju služi kao
stožer. Od ostalih kontrola važnije su gumb „Dalje“ koji zaustavlja izvršavanje trenutnog tajmera
te omogućava izvedbu animacije korak po korak odnosno tajmer po tajmer. Gumb „start“ i
„pause“ kontroliraju tok animacije isto pokretanjem tajmera sekvencijalno jednim iza drugog ali
bez pauze te ako je animacije u toku, gumb „play“ je isključen kako ne bi došlo do greške u
izvoĎenju. Kontrole koje prikazuju broj usporedbi i zamjena povezane su takoĎer sa tajmerima
jer svaki put kada se izvede Timer1 znači da se izvela zamjena, a kad se izvede Timer4 izvela se
usporedba.
54
3.2.4 Forma priprema2
Forma priprema2 je samo pojednostavljenja verzija forme priprema. Kako bi se osigurala brzina
generiranja velike količine podataka koji popunjavaju polje dodan je samo jedan ListBox u koji
se spremaju podaci i funkcije koje ga trebaju popuniti.
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click If ComboBox1.SelectedIndex = 0 Then Dim array(TextBox2.Text) As Integer For i As Integer = 0 To TextBox2.Text - 1 array(i) = RandomClass.Next(1, 100) Next For i As Integer = 0 To TextBox2.Text - 1 ListBox1.Items.Add(array(i)) Next End If If ComboBox1.SelectedIndex = 1 Then Dim array(TextBox2.Text) As Integer For i As Integer = 0 To TextBox2.Text - 1 array(i) = RandomClass.Next(1, 100) Next System.Array.Sort(array) System.Array.Reverse(array) For i As Integer = 0 To TextBox2.Text - 1 ListBox1.Items.Add(array(i)) Next End If If ComboBox1.SelectedIndex = 2 Then Dim array(TextBox2.Text) As Integer For i As Integer = 0 To TextBox2.Text - 1 array(i) = RandomClass.Next(1, 100) Next System.Array.Sort(array, 0, CInt(TextBox2.Text - 2)) For i As Integer = 0 To TextBox2.Text - 1 ListBox1.Items.Add(array(i)) Next End If Me.Hide() test.MdiParent = Mdi_forma test.Show() End Sub
Program 3.7 Isječak koda iz forme priprema2
Kao što je vidljivo u programu 3.7 broj elemenata koji će se generirati ograničen je varijablom
koja se unosi u TextBox te se nakon odabira metode iz padajućeg izbornika popunjava Listbox iz
kojeg dalje forma test može učitavati podatke. Ukoliko bi se generiranje nasumičnih brojeva
izvodilo tijekom rada forme test rad aplikacije bi se jako usporio kod rada s velikim poljima, a na
ovaj je polje već pripremljeno prije izvedbe samog testa.
55
3.2.5 Forma test
Forma test predviĎena je kao sredstvo testiranja sposobnosti algoritama na velikim poljima.
Prema tome, svi se algoritmi nalaze na formi te je svaki od njih opisan dvjema vrijednostima:
brojem zamjena i brojem usporedbi izvršnih nakon sortiranja polja.
Slika 3.14 Prikaz forme test u dizajnerskom pogledu
Slika 3.14 prikazuje raspored kontrola GroupBox10
u koju je sadržan po jedan od svakog
algoritma. Broj zamjeni i broj usporedbi dohvaća se pomoću varijabli koje su postavljenje na
mjesta u algoritmu na kojima se izvode spomenute radnje. Nakon što je jedan algoritam izvršio
sortiranje podaci se prikazuju pomoću Label-a te se ponovno dohvaća početna postavka polja iz
forme priprema2 kako bi se osiguralo „pravedno natjecanje“ meĎu algoritmima. Kontrola koja
10
GroupBox u vb.net-u predstavlja kontrolu koja omogućava grupiranje kontrola
56
grafički prikazuje rezultate testa naziva se Chart11
. Pri pokretanju forme ona je prazna i može se
popuniti podacima tek kada su svi testovi gotovi.
Chart1.Series.Add("Bubble Sort") Chart1.Series(0).Points.AddXY(1, bub_comp) Chart1.Series(0).ChartType = SeriesChartType.Column Chart1.Series.Add("Selection Sort") Chart1.Series(1).Points.AddXY(1.5, sel_comp) Chart1.Series(1).ChartType = SeriesChartType.Column Chart1.Series.Add("Insertion Sort") Chart1.Series(2).Points.AddXY(2, ins_comp) Chart1.Series(2).ChartType = SeriesChartType.Column Chart1.Series.Add("Cocktail Sort") Chart1.Series(3).Points.AddXY(2.5, coc_comp) Chart1.Series(3).ChartType = SeriesChartType.Column Chart1.Series.Add("Shell Sort") Chart1.Series(4).Points.AddXY(3, she_comp) Chart1.Series(4).ChartType = SeriesChartType.Column Chart1.Series.Add("Comb Sort") Chart1.Series(5).Points.AddXY(3.5, com_comp) Chart1.Series(5).ChartType = SeriesChartType.Column Chart1.Series.Add("Heap Sort") Chart1.Series(6).Points.AddXY(4, hea_comp) Chart1.Series(6).ChartType = SeriesChartType.Column Chart1.Series.Add("Quick Sort") Chart1.Series(7).Points.AddXY(4.5, qui_comp) Chart1.Series(7).ChartType = SeriesChartType.Column
Program 3.8 Isječak koda iz forme test
Program 3.8 sadržava isječak koda iz forme koji se odnosi samo na generiranje grafikona za
kontrolu Chart. Kontrola Chart sastoji se od serija, a svaka serija predstavlja jedan algoritam
sortiranja odnosno jedan skup podataka. Taj skup podataka mora sadržavati minimalno dvije
varijable; varijable za x-os i varijable za y-os. Varijable koje su u ovom slučaju postavljenje za
x-os su decimalne vrijednosti na razmaku od 0.5 kako bi se dobila odreĎena preglednost grafa, te
vrijednost za y-os u kojoj su sadržani podaci o izvedenim zamjenama tijekom rada algoritma.
11
Chart u vb.net-u predstavlja kontrolu koja omogućuje prikaz grafikona
57
3.2.6 Forma info
Posljednja forma je forma info koja ne sadrži nikakav dinamički sadržaj već je samo
informativnog tipa. Sastoji se od FlowLayoutPanel-a12
i Label-a u kojima su sadržani podaci o
programu.
Slika 3.15 Prikaz forme info u dizajnerskom pogledu
12
FlowLayoutPanel u vb.net-u je kontrola koja omogućava kontrolu tijeka odnsno formatiranje kontrola unutar
Panela
58
3.3 Usporedba programskog rješenja sa sličnim alatima
Radošević i sur [Radošević D i sur., 2009, str. 49] su u svom radu naveli nekoliko alata za
podučavanje programiranja poput Josef the Robot, Martino, Marta, Turringal, Darel, Karel-3D,
Guido von Robot i Alice. Od navedenih, dva alata se ističu zbog korištenja vizualizacije kao
metode podučavanja te velikog broja funkcija koju sadržavaju, a to su Guido von Robot i Alice.
U usporedbi sa programom razvijenim za potrebe ovog rada mogu se uočiti mnoge prednosti i
nedostaci. Alice je alat koji koristi 3D tehnologiju kako bi se animirali objekti koji reprezentiraju
kontrole i strukture unutar programa. Na slici 3.16 prikazani su svi glavni elementi ovog alata
poput strukture scene, prikaza 3D animacije, popisa dogaĎaja te samog toka algoritma koji
upravlja animacijom. Pri korištenju ovog alata potrebno je uložiti dosta vremena kako bi se
podesili svi parametri animacije i naučila sintaksa programskog jezika Alice. Osim toga,
potrebno je podesiti parametre dogaĎaja koji su vezani na akcije koje se izvode unutar algoritma,
podesiti scenu, kameru odnosno perspektivu i na kraju svjetlo. Na kraju ovog dugog postupka
animacija je spremna za pokretanje.
Slika 3.16 Osnovno sučelje alata Alice
59
Student programiranja koji bi želio vizualizirati izvoĎenje nekog algoritma sortiranja u programu
Alice izgubio bi puno vremena na samo podešavanje i rad s aplikacijom, umjesto da ga utroši na
učenje programiranja.
Slika 3.17 Priprema vizualizacije
Priprema vizualizacije pomoću aplikacije razvijene za ovaj rad provodi se, za razliku od alata
Alice, u tri jednostavna koraka prikazanim slikom 3.17. Tijekom priprema vizualizacije
korisniku nije potrebno nikakvo znanje programiranja te mu je uvijek ponuĎena samo jedna
opcija. Sljedeća opcija se korisniku otvara tek nakon što je uspješno unio podatke za prethodni
korak, dok je svaki korak popraćen primjerom i objašnjenjem. Korisniku koji se po prvi puta
susreće s aplikacijom treba vrlo malo vremena za postavljanje i pokretanje vizualizacije u
odnosu na ostale alate.
Slika 3.18 Osnovno sučelje alata Gudio von Robot
60
Isto takav problem kompliciranog postavljana početnih postavki javlja se i kod alata Guido von
Robot. Iako je on jednostavniji od alata Alice za njegov rad korisnik mora već poznavati velik
dio programiranja. Svaka akcija u ovom alatu provodi se sekvencijalno na temelju unesenih
naredbi koje su opet opisane potpuno novom sintaksom razvijenom samo za ovaj alat kao što je
prikazano u prozoru „Code window“ na slici 3.18. Još jedna od prednosti alata razvijenog za
potrebe ovog rada je simultano izvoĎenje više animacija. Ovakav način izvoĎenja omogućava
korisniku usporedbu algoritama ili pak jednostavnu usporedbu rezultata dok se u svim
dosadašnjim alatima scene animacije brišu nakon stvaranja novih početnih postavki i moguće je
izvoĎenje samo jedne animacije. U alatima Alice i Guido von Robot ne nudi se nikakvo
objašnjenje akcija osim vizualnog te se time dodatno opterećuje korisnika da raspozna elemente
koji su u interakciji tijekom 3D animacije ili prolaza objekta tijekom polja ukoliko se radi o alatu
Guido von Robot. Od početka pa do kraja rada s aplikacijom korisniku nije potrebno nikakvo
znanje programiranje te se ne susreće s unosom kod-a ili sintaksom algoritma. Tijekom rada
korisniku je opisan svaki korak izvoĎenja vizualizacije te koji su elementi u interakciji tijekom
izvoĎenja odreĎene akcije. Kako usporedba algoritama ne bi ostala samo na korisniku i
simultanom izvoĎenju algoritama aplikaciju je dodana funkcija usporednog testa, koja isto tako
vizualno i objašnjenjem prikazuje razliku izmeĎu algoritama koji su obraĎeni u ovom radu. S
obzirom da su ovi alati razvijeni za vizualizaciju generalnih programskih problema, a aplikacija
ovog rada je više orijentirana na algoritme sortiranja potrebno je izvršiti usporedbu s alatom koji
isto tako vizualizira algoritme sortiranja u edukativne svrhe. Jedan od boljih alata razvijenih na
sveučilištu Smith u Americi je web aplikacija pod nazivom „Sorting algorithms“. [Thiebaut D,
1997, str 2.].
Slika 3.19 Osnovno sučelje alata „Sorting algorithms“
61
U usporedbi alata „Sorting algoritms“ sa aplikacijom razvijenom za potrebe ovog rada odmah u
početku su vidljive znatne razlike. Alat „Sorting algorithms“ je razvijena pomoću Java
programskog jezika te je potrebno instalirati Java 2.0 programsku okolinu za njezino pokretanje.
Aplikacija nakon pokretanja ne nudi nikakve napredne postavke početnog polja koje se
prosljeĎuje na sortiranje, nego se nasumično generira visina stupca koja reprezentira vrijednost
za fiksni broj elemenata. Tijekom izvoĎenja vizualizacije ne opisuju se koraci koji se provode,
nego ostaje na korisniku da sam zamijeti promjene. Nadalje, nije omogućena nikakva usporedba
algoritama koja bi korisniku prikazala razlike meĎu algoritmima o kojima uči. Iako aplikacija
„Sorting algorithms“ nudi jednako velik izbor algoritama jasno je da je aplikacija razvijena za
potrebe ovog rada naprednija i sadržava ima veću edukativnu vrijednost.
62
4. Zaključak
U ovom radu obraĎeni su neki od poznatijih algoritama sortiranja. Neki od njih daleko su od
brzih ili dobrih algoritama sortiranja no zaslužili su svoje mjesto u povijesti razvoja algoritama
sortiranja. Sve je još davno počelo od jednostavnog mjehurićastog sortiranja. Danas, sve
složeniji algoritmi poput brzog sortiranja koji istovremeno unutar sebe koristi sortiranje
umetanjem te radi na principu rekurzije ima titulu najbržeg stabilnog algoritma sortiranja. Razvoj
i kontinuirano poboljšavanje algoritama sortiranja je nadasve potrebno jer se sve većom pojavom
informatizacije povećava i broj podataka koje je potrebno obraditi. Prije dvadesetak godina
računala nisu imala veliki kapacitet diskova ili procesorsku moć te nije bilo potrebe za razvojem
kompleksnih algoritama. MeĎutim, danas se gotovo svi podaci spremaju na servere ili lokalna
računala ogromnih kapaciteta pri čemu povećanje procesorske moći ne može kompenzirati
nedostatak algoritma koji sortira podatke. Prema tome ako se u bližoj budućnosti neće provoditi
usavršavanje ovakvih algoritama, razvoj računala će ih preteći pa će se i vrlo brzi algoritmi
poput brzog sortiranja pronaći u problemima sortiranja podataka veličine nekoliko tisuća
terabajta. Da bi mladi programeri mogli raditi na razvoju novih algoritama prvo moraju svladati
postojeće, a namjena programa razvijenog za potrebe ovog rada je bila olakšati učenje
algoritama sortiranja iz razloga što prikazuje i objašnjava svaki korak tijekom rada algoritma na
jednostavan i razumljiv način. Osim toga, program pruža mogućnost da korisnik manipulira
ulaznim podacima i tijek same animacije. U usporedbi s edukacijskim programima poput „Guido
von robot“ i „Alice“ alat za vizualizaciju algoritama sortiranja je jednostavan za korištenje zbog
karakteristika poput jednostavne kontrole i intuitivnog sučelja. MeĎutim, spomenuti programi
omogućuju vizualizaciju većeg broja programskih koncepata, što u konačnici otežava rad s
programom. Prema tome, kod edukacijskih programa krivulja učenja bi trebala biti vrlo mala ili
ne bi trebala uopće postojati iz razloga što se pokušava educirati korisnika o zadanoj temi, a ne
radu s programom. Budući rad će biti usmjeren na proširenje obrazovnih mogućnosti programa
na način da će korisniku tijekom rada vizualizacije postavljati pitanja s više ponuĎenih odgovora
poput pitanja „Koji će se sljedeći elementi usporediti ?“.
63
Zahvala
Tijekom implementacije vizualizacije algoritama navedenih u radu suočio sam se s brojnim
problemima i zaključio kako je programiranje vrlo kreativan proces. Svaka funkcija programa
izgledala je kao prepreka koja se može preskočiti na tisuću načina. Iz tog razloga zahvalan sam
mentoru da mi je pružio priliku rada na tako kreativnom projektu i nadam se da će se u mojem
daljnjem obrazovanju naći što više zanimljivih algoritama.
Literatura
1. Astrachan O. (2003). Bubble Sort: An Archaeological Algorithmic Analysis. Duke
University. Dostupno 19.8.2011. na www.cs.duke.edu/~ola/bubble/bubble.pdf
2. Bentley J.L., McIlory M.D. (1993). Engineering a Sort Function. AT&T Bell Laboratories.
Dostupno 12.8.2011. na
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.14.8162&rep=rep1&type=pdf
3. Canaan C., Garai M. S., Daya M. (2011). World Applied Programming, Chiredzi:
Information institute
4. Cormen T.H., Leiserson C. E., Rivest L.R., Stein C.(2001) Introduction to Algorithms
(2.izdanje). MIT Press
5. Huntley, H. E. (1970). The Divine Proportion: A Study in Mathematical Proportion. New
York: Dover Publications
6. Johnson J. (2003).Then, Now and Beyond… A Look at the Past 30 Years of Educational
Software in Learning & Leading with Technology . Dostupno 18.8.2011. na
7. Knuth D.E. (1998). The Art Of Computer Programming: Volume 3 / Sorting and Searching
( 2. izdanje ). Boston: Addison-Wesley Professional
8. Lacey S. (1991). A fast, easy sort , Byte Magazine
9. Manager R., Marušić M. (2007). Strukture podataka i algoritmi ( 3. izdanje ) Dostupno
29.7.2011. na http://web.studenti.math.hr/~manger/spa/skripta.pd
64
10. Musser D. (1997). "Introspective Sorting and Selection Algorithms". Dostupno 1.9.2011 na
http://www.cs.rpi.edu/~musser/gp/introsort.ps
11. Radošević D., Orehovački T., Lovrenčić A. (2009). New Approaches and Tools in
Teaching Programming. Dostupno 18.8.2011. na
http://bib.irb.hr/datoteka/427643.CECIIS2009_Radosevic_Orehovacki_Lovrencic.pdf
12. Ramesh C.P. (2008). Study and Comparison of Various Sorting Algorithms Patiala: Thapar
University
13. Schirra J.R.J. (2005). Foundation of Computational Visualistics. Wiesbaden: Duv
14. Shaw B.I. (1992). Animation of Sort Algorithms, Baruch College. Dostupno 17.8.2011 na
http://homepages.dcc.ufmg.br/~dorgival/applets/SortingPoints/SortingPoints.html
15. Slamić M. (2011). Primjena jednodimenzionalnih polje – sortiranje. Dostupno 28.9 na
http://informatika.tvz.hr/php/skini_repoz.php?id=16045&id1=15&id2=2
16. Spence R. (2007). Information Visualization: Design for Interaction (2. izdanje), Prentice
Hall
17. Thiebaut D. (1997). Sorting Algorithms. Dostupno 30.9 na
http://maven.smith.edu/~thiebaut/java/sort/demo.html
18. Weiss M.A. (1997). Data Structures and Algorithm Analysis in C ( 2. izdanje ). Boston:
Addison-Wesley Professional