algoritmi sortiranja seminarski rad

UNIVERZITET U BIHAĆU TEHNIČKI FAKULTET ODSJEK: ELEKTROTEHNIKA SMJER: INFORMATIKA

PREDMET: Algoritmi i strukture podataka ZADATAK SEMINARSKOG RADA: Algoritmi sortiranja

Shell sort

Merge sort

Heap sort

Radix sort

Profesor: doc.dr. Muharem Kozić Školska godina: Studenti: Asistent: dipl.ing. Eldin Okanović 2012/2013 Fikret Bašić 690 Denis Žerić 687 Dinko Ćejvanović 686 Faruk Hamzabegović 673 Armin Felić 674

2 | A l g o r i t m i s o r t i r a n j a

SADRŽAJ 1.0 UVOD ................................................................................................................................................. 3

2.0 RAZRADA ........................................................................................................................................... 4

2.1 SHELL SORT ................................................................................................................................... 4

2.2 HEAP SORT .................................................................................................................................... 9

2.2.1 Heap ....................................................................................................................................... 9

2.2.2 Sortiranje heap-a ................................................................................................................. 10

2.3 MERGE SORT ............................................................................................................................... 12

2.4 RADIX SORT ................................................................................................................................. 15

3.0 ZAKLJUČAJ ....................................................................................................................................... 19

4.0 SLIKE ................................................................................................................................................ 20

5.0 LITERATURA .................................................................................................................................... 20

6.0 KOMENTAR ..................................................................................................................................... 21


1.0 UVOD Ovaj rad smo posvetili algoritmima, čisto ciljanim metodama riješavanja mnogih matematičkih

problema. U našem slučaju to su mnogi apstraktni algoritmi sortiranja koji, kao što sam naziv kaže,

služe radi sortiranja raznih elemenata (u našim slučajevima, brojeva).

Za nas posmatrače jedina razlika koja nas može brinuti u tome jeste brzina izvršavanja samoga

sortiranja. Ipak bitno je znati da svaki tip algoritma sortiranja ima svoj drugačiji pristup rada. Jedni su

slični drugima i čine određene skupove ili kategorije. Drugi pak predstavljaju pod-algoritme sortiranja

za neke složenije programe, itd.

Mi čemo se baviti sa četri ne toliko poznata u javnosti, ali jako bitna za razvoj algoritama sortiranja,

Merge sort, Shell sort, Radix sort i Heap sort. Same nazive i funkcije čemo najčešće ostavljati u

engleskome jeziku radi anotacije i razumijevanja prema samom izvornom jeziku.

Sva naša četiri algoritma su različita i posebna na svoj način i ustvari ima svoje vlastite kategorije u

koje spadaju. Npr. Merge sort koristi rekruzivne funkcije i tip 'divide and conquer' gdje elemente

prvo dijeli pa ih onda provjerom ponovo spaja nazad. Shell sort ustvari predstavlja tipični n*n

algoritam, mada po svom izvođenju može biti jako koristan u nekim uslovima. Radix sort koristi

poredane listove naprema hash tabeli u principu tehnike ulančavanja, a Heap sort tehniku jasno

sortiranog binarnog stabla.

U našem radu čemo također pojasniti mane i prednosti svakoga algoritma, način i tehniku izvođenja,

kriterij velikog O te predstaviti njihov pseudo kod bio on u kodnom ili tekstualnom obliku kako bi što

bolje razumjeli te koristili date algoritme.


2.0 RAZRADA

2.1 SHELL SORT Najveci uzrok neefikasnosti kod insertion sort algoritma je slucaj malih elemenata koji se nalaze blizu

kraja niza. Posto se nalaze blizu kraja, oni se umecu u relativno dugacak niz, a posto su mali umecu

se na pocetak te je potrebno izvrsiti pomjeranje velikog broja elemenata kako bi se oni postavili na

svoje mjesto.

Shell sort, algoritam visestrukog sortiranja umetanjem kojeg je razvio Donald L. Shell 1959. godine,

predstavlja unaprijedenu verziju insertion sorta. Osnovni cilj je da se ,,skrati put" ovakvih elemenata.

Shell sort koristi cinjenicu da insertion sort funkcionise odlicno kod nizova koji su ,,skoro sortirani".

Algoritam radi tako sto se niz dijeli na veci broj kratkih kolona koje se sortiraju primjenom insertion

sort algoritma, cime se omogucava direktna razmjena udaljenih elemenata. Broj kolona se zatim

smanjuje, sve dok se na kraju insertion sort ne primijeni na cijeli niz. Medutim, do tada su ,,pripremni

koraci" dijeljenja na kolone doveli niz u ,,skoro sortirano" stanje te se zavrsni korak prilicno brzo

odvija.

Ilustracija jedne varijante Shell sort algoritma na slijedecem nizu:

(9, 10, 16, 8, 5, 11, 1, 12, 4, 6, 13, 7, 14, 3, 15, 2)

.

U prvoj fazi podijelimo niz na 8 kolona.

9, 10, 16, 8, 5, 11, 1, 12,

4, 6, 13, 7, 14, 3, 15, 2

i primijenimo insertion sort na sortiranje svake kolone ponaosob.

4, 6, 13, 7, 5, 3, 1, 2,

9, 10, 16, 8, 14, 11, 15, 12

Ovim je dobijen niz (4, 6, 13, 7, 5, 3, 1, 2, 9, 10, 16, 8, 14, 11, 15, 12)


Primijetimo da je ovim veliki broj malih elemenata (npr. 2) kroz samo jednu operaciju razmjene

dosao u prvu polovinu niza.

U sljedecoj fazi dijelimo niz na 4 kolone

4, 6, 13, 7,

5, 3, 1, 2,

9, 10, 16, 8,

14, 11, 15, 12


4, 3, 1, 2,

5, 6, 13, 7,

9, 10, 15, 8,

14, 11, 16, 12

Ovim je dobijen niz (4 3 1 2 5 6 13 7 9 10 15 8 14 11 16 12)

U sljedecoj fazi dijelimo niz na dvije kolone.

4, 3,

1, 2,

5, 6,

13, 7,

9, 10,

15, 8,


14, 11,

16, 12


1, 2,

4, 3,

5, 6,

9, 7,

13, 8,

14, 10,

15, 11,

16, 12

Ovim se dobija niz (1, 2, 4, 3, 5, 6, 9, 7, 13, 8, 14, 10, 15, 11, 16, 12)

.

Na kraju se dobijeni sortira primjenom insertion sort algoritma, cime se dobija niz

(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

.

Napomenimo da je podjela na kolone samo fiktivna operacija i da se ona u implementaciji izvodi

tako sto se prilikom umetanja elementa ne razmatraju susjedni elementi vec elementi na rastojanju

gap gdje gap oznacava tekuci broj kolona

Pseudo kod Shell algoritma:


inc ← round(n/2)

while inc > 0 do:

for i = inc .. n − 1 do:

temp ← a[i]

j ← i

while j ≥ inc and a[j − inc] > temp do:

a[j] ← a[j − inc]

j ← j − inc

a[j] ← temp

inc ← round(inc / 2.2)

S obzirom da je u poslednjoj iteraciji spoljne petlje gap ima vrijednost 1, algoritam u posljednjoj

iteraciji izvodi obican insertion sort algoritma.

Ono sto se moze proizvoljno odredivati je broj kolona na koji se vrsi dijeljenje niza u fazama (broj

kolona se obicno oznacava sa gap i ovaj niz se u literaturi cesto oznacava gap sequence). Originalni

Shellov prijedlog (koji je i koriscen u prethodnom primjeru i implementaciji je [n/2], [n/4] ,....,

[n/2k],....,1). Kako bi se garantovala korektnost, na kraju je potrebno primijeniti insertion sort bez

podjele na kolone (tj. posljednji clan sekvence mora biti 1).

U zavisnosti od sekvence varira i slozenost najgoreg slucaja. Originalna sekvenca ima slozenost O(n2)

dok postoje druge sekvence koje garantuju slozenost O(n3/2), O(n4/3) pa i O(nlog2n).

Slika 1. Metode dijeljenja u shell sort-u


Slika 2. Poređenje među različitim algoritmima

Shell sort se danas rijetko koristi u aplikacijama, jer obavlja vise operacija i ima veću šansu promašaja

željenih elemenata od quicksorta. S druge strane, implementira se kratkim kodom, pa moze posluziti

kao podalgoritam – da sortira krace podnizove i da spriječi nepotrebno usporavanje u slučaju

prelaženja datog limita u pozivanju rekruzivne funkcije.


2.2 HEAP SORT Heap sort je jedan od često i novije korištenih algoritama sortiranja koji po svojoj strukturi i kompleksnosti iskazuje samu evoluciju razvoja algoritama do sada. Po analizi to je također jedan od najbržih algoritama za korištenje u svrhu sortiranja niza u slučaju složenog broja elemenata. Po kriteriju efikasnosti izvođenja unutar rada (veliko O) uzima se prvo 'log(n)' za sve standardne operacije koje možemo raditi sa stablima i hrpama u ovome slučaju. Ipak naš algoritam sortiranja će se ponavljati u skladu sa vremenom sve dok ne poredamo sve elemente tako da će veliko O ustvari biti 'n*log(n)'.

Slika 3. Graf ovisnosti o broju elemenata i vremenu izvršavanja.

2.2.1 Heap Heap u prijevodu znači kamara ili hrpa i , ironično po nazivu, ustvari predstavlja jasno određeno i definirano binarno stablo gdje su elementi raspoređeni po određenim pravilima i gdje se po istima i skidaju i dodaju sa ili na njega.

ili

Slika 4. Slika 5. Heap stablo? Ne. Heap stablo? Da. Ranije spomenuta pravila se definiraju na sljedeći način. Postoje dva pravila prilaska elementima hrpa. Jedna su da roditelji uvijek budu manji elementi od svoje djece (prilikom čega će na mjesto korijena, odnosno 'root'-a, uvijek nalaziti najmanji element u tome stablu). Druga ustvari predstavljaju ona pravila koja su vežu da veći element uvijek bude roditelj a njegova djeca da budu manji elementi (ovdje će dakako korijen uvijek biti najveći element). U primjeni se najčešće koriste druga pravila (vezana za većega roditelja) koja ćemo i koristiti u narednim pojašnjenjima.


Prilikom dodavanja svakoga elementa u hrpu moramo paziti gdje ćemo ga postaviti. Tu možemo koristiti standardno pravilo dodavanja elementa u stablo (sa lijevo na desno sve dok se određeni čvor ne popuni). Nakon toga dolazi do provjere i ako je potrebno , zamjene, svakoga čvora djeteta sa svojim roditeljom sve dok se stablo ponovno ne uravnoteži. Prilikom izbacivanja svakoga elementa izbacivamo samo korijen i njega zamjenjuje zadnji element u stablu. To je i sami osnovni princip rada sortiranja uz upotrebi hrpa kojega čemo ubrzo objasniti.

Slika 6. Formiranje hrpa. Iako je to ustvari jedan oblik stabla, u praksi se ne koristi toliko često ovaj oblik, nego jednostavno oblik sličan izgledu samoga niza. Npr. iz prve slike kao primjer takvoga stabla mogli smo uzeti elemente i napisati ih ovako: [100 19 36 17 3 25 1 2 7] Ovom metodom prilikom traženja i analize roditelja čvorova sa njihovom djecom, koristimo sljedeće formule: 2X + 1 - za prvi čvor djeteta u odnosu na roditelja, odnosno na lijevi čvor 2X + 2 - za drugi čvor djeteta u odnosu na roditelja, odnosno na desni čvor 'X' predstavlja indeks određenoga element roditelja a rezultat je indeks djeteta.

2.2.2 Sortiranje heap-a

Sortiranje uz pomoć hrpa predstavlja samo dodatnu operaciju pored već standardnih operacija koje možemo da učinimo sa njima. Prilikom formiranja svakoga sortiranog niza potrebno je samo da element koji se nalazi na poziciji korijena izbacimo iz stabla i postavimo ga u novi niz. Nakon toga zadnji element iz stabla ide na poziciju korijena, cijelo stablo se ponovo reformira po zakonitostima heap-a te se ponavlja isti postukak izbacivanja.


Ako želimo da postavimo elemente od najmanjeg prema najvećem onda ih ubacujemo sa petljom od zadnje pozicije iz niza (pošto idemo metodom da roditelj uvijek bude veći od djeteta). U sljdećem primjeru koristit ćemo se standardnom tehnikom prikaza elemenata heap-a kao niza te korak po korak prikazati njegovo sortiranje. Niz: [58 41 37 10 47 61] Heap(1) : 58 47 37 10 41 61 58 47 61 10 41 37 61 47 58 10 41 37 // Prvi element kojega izbacivamo kao najveći Heap(2) : 37 47 58 10 41 // Svakim izbacivanjem zadnji element postaje prvi 58 47 37 10 41 Heap(3) : 41 47 37 10 47 41 37 10 Heap(4) : 10 41 37 41 10 37 Heap(5) : 37 10 Heap(6) : 10

Posmatranjem gornjih elemenata možemo da uvidimo da odozgo prema dole ide od najvećeg do najmanjeg, a odozdo prema gore od najmanjeg prema najvećem broju inteđera. Naši elementi su sortirani. Opće korišten pseudo kod 'heap sort' - a je sljedeći: Heapsort(A) { BuildHeap(A) for i <- length(A) downto 2 { exchange A[1] <-> A[i] heapsize <- heapsize -1 Heapify(A, 1) } BuildHeap(A) { heapsize <- length(A) for i <- floor( length/2 ) downto 1 Heapify(A, i) } Heapify(A, i) { le <- left(i) ri <- right(i) if (le<=heapsize) and (A[le]>A[i]) largest <- le


else largest <- i if (ri<=heapsize) and (A[ri]>A[largest]) largest <- ri if (largest != i) { exchange A[i] <-> A[largest] Heapify(A, largest) } }

2.3 MERGE SORT Rijec je o rekurzivnom algoritmu. Ukoliko se zadani niz sastoji samo od 1 elementa, tada je vec sortiran. Inace se zadani niz podijeli se na dva manja niza podjednakih duzina. Ta dva manja niza zasebno se sortiraju rekurzivnim pozivima istog algoritma. Zatim se ti mali sortirani nizovi sazimlju u jedan (sortiran) uz pomoc prethodno opisanog postupka sazimanja (merge).

Objasnjenje sortiranja pomocu Merge sort-a:

Radi jednostavnosti, pretpostavimo da je nasa lista ustvari niz.Osnovna ideja spajanja nizova koristenjem merge sort-a je da brzo mozemo spojiti dva sortirana niza u jedan. Ovaj proces se zove merging step.

Za spajanje dva sortirana niza, prvo moramo staviti indeks,koji pocinje sa nulom, u oba niza na

mjesto gdje se najmanji element nalazi. Usporedjujuci elemente za svaki indeks, biramo manji

element, stavljamo ga u niz u kojem ce se nalaziti elementi oba sortirana niza, i povecavamo indeks

manjeg elementa. Po ovoj metodi, mi stalno selektiramo sljedeci najmanji element od dva niza te ga

spajamo u jedan sortirani niz.


Slika 7. 'Merging' korak

Koristenjem merge step-a takodjer mozemo sortirati i niz koji nije sortiran. Pocinjemo sa

pretpostavkom da je svaki element niza ustvari zasebni sortirani niz koji ima duzinu 1. Nakon toga,

mi spajamo svaki par elemenata u novi niz koji ima duzinu 2. Nakon toga, mi spajamo svaki niz

duzine 2 u novi niz koji ima duzinu 4, te taj proces ponavljamo dok ne dodjemo do niza cija je duzina

jednaka zbiru duzina pojedinih elemenata.U nastavku je prikazan primjer sortiranja 8 elemenata u

sortirani niz koji ima duzinu 8.

Slika 8. 'Merge' sortiranje


Pseudo kod Merge sort-a:

for (int i = 1; i < duzina; i *= 2) { for (int j = 0; j < duzina - i; j += 2*i) { Merge(&A[j], i, min(2i,duzina-j)); } }

Gdje je:

i=duzina redova koji se spajaju

duzina=duzina niza A

j=indeks pocetnih elemenata u nizovima koji se spajaju

&A[j]=pokazuje na pocetni element u prvom nizu koji se spaja

min(2i, duzina-j)=duzina oba niza gdje drugi niz zavrsava u zavisnosti od elemenata prvog

niza(najcesce je 2i,ali nekad moze i biti krace, ponovo u zavisnosti od prvog niza)

Vremenska analiza slozenosti Merge sort-a se moze matematicki prikazati formulom:

(log2 n + 1) * O(n) = O(n log n)

Zahvaljujuci ovakvoj ocjeni, radi se o jednom od najbrzih algoritama za sortiranje. Prednost ovog

algoritma je ta sto se moze sortirati velika kolicina podataka koji su pohranjeni na nekoj vanjskoj

memoriji racunara, te njegova brzina, dok manu ovog algoritma cini veliki utrosak memorije zbog

kreiranja dodatnog niza potrebnog u procesu sortiranja.


2.4 RADIX SORT Radix sort se bazira na pravljenju Hash tabele korištenjem tehnike ulančavanja. Radix sort sortira

elemente prvo po jedinicama, zatim po deseticama , itd. Sortiranje će se izvršiti onoliko puta koliko

cifara ima najveći broj u nizu. Radix sort je izmišljen 1954.godine na MIT(Massachussets institute of

Technology) od strane Harolda H. Sewarda. Radix sort je jedan od algoritama sortiranja koji je

„sporiji“ , tj. treba mu više vremena da izvrši sva ponavljanja sortiranja.

Primjer korištenja Radix sorta :

NIZ :

9 179 139 38 10 5 36

Inicijaliziramo dvije varijable „m“ i „n“ koje su tipa int.

int m = 10;

int n = 1;

Pozivamo funkciju koja ce redati svaki element niza u listu koju smo napravili, računajući index

(poziciju) na koju će postaviti taj element u listu, koja će raditi taj element modulo m, a zatim taj

rezultat podijeliti sa n. Lista će se sastojati od 10 elemenata , a indexi će ići od 0 do 9, jer cifre u

brojevima mogu biti brojevi od 0 do 9.

Uzimamo prvi element niza - 9 :

pozivamo funkciju koja će raditi sljedeće :

Niz[0] = 9;

9 %10 = 9;

9/1 = 9;

Znači element 9 ćemo postaviti u listu na poziciju 9. To ponavljamo za svaki element.

Niz [1] = 179;

179%10 = 9;

9/1 = 9;

Element 179 postavljamo u tabelu na poziciju 9.

Niz [2] = 139;

139 %10 = 9;

9/1= 9;

Element 139 postavljamo na poziciju 9.

Niz [3] = 38;


38%10 = 8;

8/1=8;


Niz [4] = 10;

10%10=0;

0/1 = 0;


Niz [5] = 5;

5%10= 5;

5/1 =5;


Niz [6] = 36;

36%10 = 6;

6/1 = 6;


Zatim sad te elemente iz liste redamo u novi niz. Uzimamo elemente od početka prema kraju liste,

novi niz će izgledati ovako:

10 5 36 38 9 179 139

0

1

2

3

4

5

6

7

8

9 139 179 9

38

36

10

5


Taj novi niz ćemo opet sortirati ali ćemo prvo uraditi sljedeće:

m = m* 10;

n= n* 10;

Sad nam je m = 100, n= 10;

Ponavljamo isti postupak kao i u prvom koraku samo što sortiramo novi niz ,i radimo %100 a zatim

dijelimo sa 10;

Lista će nakon drugog koraka sortiranja izgledati ovako:

0

1

2

3

4

5

6

7

8

9

Sad ponovimo postupak, pravimo novi niz i redamo elemente. Novi niz će izgledati ovako:

5 9 10 36 38 139 179

Niz nam je u ovom slučaju već sortiran , ali se sortiranje mora opet izvršiti jer najveći broj ima 3 cifre,

znači radix sort će se izvršiti 3 puta.

Isti postupak ponavljamo opet.

m = m*10;

n = n*10;

m= 1000;

n=100;

Sortiramo opet novi niz.

5 9

10

36 38 139

179


Lista će onda izgledati ovako:

0

1

2

3

4

5

6

7

8

9

Niz će izgledati ovako:

5 9 10 36 38 139 179

Niz nam je sada sortiran.

Pseudo kod radix sorta je :

Radix Sort (Sorting array A[size]) Create all of the bins. From the least significant digit to the most significant digit { For each element (from the first to the last) { Isolate the value of the significant digit. Store the element in the bin with the matching significant digit value. } For each bin (from the first to the last) { Retrieve all of the elements and store them back into the array. } }

Destroy all of the bins.

Radix sort se bazira na provjeravanju cifara nekog broja,međutim ako se u nekom nizu nalazi jedan

broj kojima ima vise cifara od svih ostalih, sortiranje ce se izvršavati bespotrebno nekoliko puta.

Kriterij velikog O za ovaj algoritam iznosi O(k*n) gdje 'k' predstavlja maksimalan broj cifra, a 'n' broj

elemenata.

5 9 10 38 36

139 179


3.0 ZAKLJUČAJ Ovim smo završili objašnjenje naših algoritama sortiranja. Dobro je uvijek imati na umu da iako

postoje mnogo noviji i , moglo bi se reći, interesantniji algoritmi sortiranja od već ranije utvrđenih, to

zasigurno ne mora značiti da su efikasniji ili barem nisu efikasni kao neki ovisno o vašem pristupu

rada, elementima kojima se koristiti, njihovom količinom i slično.

Ponekad je dobro proučiti većinu njih za sve one koji se žele ozbiljnije baviti njihovom

problematikom i uči u sam srž njihovih prednosti i mana, jer kako postoje algoritmi pretraživanja,

tako postoje i njihove optimizirane verzije. Mi njih u ovome radu nismo prošli, jer što je kompleksniji

algoritam to ga je i teže optimizirati, ali i onda ponekad znamo samo dobiti na dodatnim

prednostima, ali isto tako i dodatnim manama.

Ovi algoritmi postoje gotovo kao i sama matematika, ali tek danas vidimo njihovu pravu primjenu u

informatičkim naukama. Proči će još mnogo godina dok se ne nađe najboljia verzija nekoga algoritma

koja će zamijeniti sve ostale, ali do tada na nama je da usavršavamo već postojaće i da izvlačimo ono

maksimalno iz njih.


4.0 SLIKE

Slika 1. Metode dijeljenja u shell sort-u

Slika 2. Poređenje među različitim algoritmima

Slika 3. Graf ovisnosti o broju elemenata i vremenu izvršavanja. Slika 4. Heap stablo? Ne. Slika 5. Heap stablo? Da. Slika 6. Formiranje hrpa.

Slika 7. 'Merging' korak

Slika 8. 'Merge' sortiranje

5.0 LITERATURA 1. "Jumping into C++" , Alex Allain, San Francisco, 2012

2. "Programiranje i algoritmi" , N.Pavković, D,Marjanović, N.Bojčetić, Zagreb, 2005

3. http://xoax.net/comp_sci/crs/algorithms/index.php (8.6.2013)

4. http://www.cs.auckland.ac.nz/software/AlgAnim/ (7.6.2013)

5. http://www.cprogramming.com/tutorial/computersciencetheory/sortcomp.html (7.6.2013)


6.0 KOMENTAR

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

__________________________________________________

algoritmi sortiranja seminarski rad

Documents