algoritmi sortiranja - wolfram mathematica

8/12/2019 Algoritmi sortiranja - Wolfram Mathematica

http://slidepdf.com/reader/full/algoritmi-sortiranja-wolfram-mathematica 1/16

ALGORITMI SORTIRANJA

Mirnes Smajilović



2

Uvodni dioU ovom radu biće obrađeni i objašnjeni alogoritama za sortiranje: selection-sort, insert-sort,

merge-sort i quick-sort. Praktično ćemo pokazati koji od navedenih algoritama je nabrži.



3

Selection-sortOvo je jedan od najjednostavnijih algoritama sortiranja.

Moguće ga je realizovati u više varijanti.

Sortiranje od manjeg ka većem – uzlazno

„Selection-sort“ algoritam se sastoji u sljedećem: za najmanji element uzmemo prvi element

liste, a zatim ga poredimo redom sa ostalim elementima u listi. Ukoliko se nađe u listi element

manji od njega, onda taj manji element zamijenimo sa elementom na prvom mjestu, i

postupak nastavljamo dalje na isti način, dok ne uporedimo prvi (trenutno najmanji) i zadnji

element. Na kraju dobijamo na prvom mjestu najmanji element u listi. Postupak se tako

nastavlja za preostale elemente od drugog do zadnjeg. Na taj način do bijamo sortirano listu –

od manjeg ka većem. Implementacija ovog algoritma u programu Mathematica izgleda ovako:

SelectionSort[l_]:=Module[{i,j,tmp,min,lista}, (*lokalnepromjenjljive su ovdje*)

lista=l; (*kreiramo privremenu listu koju cemo i vratiti,kako ne bi promjenili original*)

For[i=1,i<Length[lista],i++,

min=i; (*min je pozicija najmanjeg elementa u listi, zapocetak stavljeno na i*)

For[j=i+1,j<=Length[lista],j++,

If[lista[[j]]<lista[[min]],min=j

(*Ako je element na poziciji j manji od dosadasnjegnajmanjeg elementa,

promjeni vrijednost min na tu poziciju*)

](*kraj if*)]; (*kraj j petlje*)

tmp=lista[[min]];lista[[min]]=lista[[i]];lista[[i]]=tmp;(*ova 3 reda mijenjaju elementa na pozicijama "min" i

"i"*)

]; (*kraj i petlje*)

Return[lista]

](*kraj modula*)



4

U samom kodu programa Mathematica smo koristili zamjenu indeksa umjesto stvarnih

vrijednosti elemenata dok se ne ustanovi koji je element najmanji na nekom mjestu, a nakon

toga se eventualno vrši zamjena samo dva elementa u listi, što je svakako opravdano jer su

indeksi prirodni brojevi od 1 do dužine liste, a elementi liste mogu biti i brojevi npr.

10000000000000000.

Sada ću nastojati objasniti prethodni kod.

Funkciju koja će vršiti sortiranje selekcijom nazvat ćemo SelectionSort čiji je argument

jedino (sortirana ili nesortirana) lista elemenata.

Radi jednostavnijeg rada sa lokalnim varijablama, kompletnu funkciju definišemo kao modul.

Nakon definisanja potrebnih varijabli, pravimo kopiju proslijeđene liste kako je nebi smo

promijenili.

Sada puštamo da nam indeks i redom prolazi čitavom listom, od prvom do predzadnjeg

elementa (zadnji će već ostati sortiran kada se uporedi predzadnji i zadnji). Za najmanji

element u i-tom koraku uzimamo baš element sa indeksom i, dakle min=i. Nakon toga, za to

fiksno i, puštamo drugi indeks j da ide od prvog elementa iza onog sa pozicijom i do krajaliste i tom prilikom poredimo elemente na poziciji j i min, i ako se desi da je element na

poziciji j manji od elementa na poziciji min, onda, jasno, min=j.

Nakon što j uzme vrijedost zadnje pozicije u listi vrši se zamjena elemenata na poziciji i i min

(jer je u početku min=i, a može se za neko j desiti da je tačno

lista[[j]]<lista[[min] pa onda min=j)

Zamjena vrijednosti dviju varijabli se skoro uvijek vrši na način da uvedemo i treću npr. tmp,

pa onda imamo

tmp=lista[[min]];lista[[min]]=lista[[i]];lista[[i]]=tmp;

čimo smo izvršili zamjenu elemenata na mjestima i i min.

Nakon ovog koraka brojač i se inkrementira, i nastavlja se program istim postupkom.

Na kraju, kada brojač i pretekne vrijednost predzadnje pozicije u listi, vraćamo kopiranu listu

samo sada sortiranu.

Return[lista]

For[i=1,i<Length[lista],i++,

min=i;

For[j=i+1,j<=Length[lista],j++,

If[lista[[j]]<lista[[min]],min=j

]];



5

Ono što se može zapaziti u gore datom kodu za Selectsort, jeste da se zamjena vrijednosti

elemenata na pozicijama i i min uvijek događa, tj. i kada je lista sortirana. To se može izbjeći

ubacivanjem jednog If-a, na sljedeći način:

if[min!=i,tmp=lista[[min]];lista[[min]]=lista[[i]];lista[[i]]=tmp];

Kasnije ćemo se uvjeriti da skoro i nema razlike, no meni se ipak činilo da bi ovo moglo bar

malo ubrazati sortiranje, tako što će se izbjeći suvišne promjene pozicija elemenata.

U sljedećoj tabeli, prva kolona je broj elemenata u listi i još govori da su elementi u toj listi od

1 do tog broja (nesortirano), a druga vrijeme potrebno da se sortiraju elementi te liste.

10 0.

100 0.016200 0.094

400 0.437

500 0.656

1000 2.594 Grafik za ovu tabelu je

200 400 600 800 1000Broj elem . u listi

0.5

1

1.5

2

2.5

Vrijeme Selection sort

Selection-sort (bez If-a)

Teško je donijeti zaključak iz ove analize vezan za zadnje razmatranje sa dodatnim If-om. Iste

liste su u predmetu sortiranja. Radi poređenja navodim obje (lijevo sa If-om, desno bez):10 0.

100 0.016

200 0.109

400 0.422

500 0.6721000 2.672

10 0.

100 0.016

200 0.094

400 0.437

500 0.6561000 2.594



6

Dakle, skoro je isto.

Razmotrićemo kako se ponaša ovaj algoritam kada su u pitanju liste koje su već sortirane u

odnosu na nesoritarane liste.

Kada je u pitanju sortirana lista imamo tabelu lijevo, a nesortirana - tabelu desno:

10 0.

100 0.031

200 0.094

400 0.406

500 0.641

1000 2.546

10 0.

100 0.016

200 0.094

400 0.437

500 0.656

1000 2.594

Ne može se apsolutno tvrditi da je Selection sort brži na sortiranim od nesortiranih listi, ali

vidimo da je u ukupnom vremenu na svim testnim listima bolji na sortiranim.

Ovim sam završio Selection-sort algoritam.

Insert-sortInsert-sort algoritam je takodjer jednostavan a radi na principu da uzimamo prvi slijedeći

element liste i stavljamo ga na odgovarajuće mjesto u već sortiranoj listi – tj. svi elementi

ispred njega su već sortirani.

Implementacija ovog algoritma u Mathmetici izgleda ovako:

Funkcija se zove InsertSort i prima jednu listu i vraća sortiranu listu.

Ovaj napisani program radi na sljedeći način.

Njaprije pravimo kopiju proslijeđene liste kako je nebi smo promijenili.

InsertSort[l_]:=Module[{lista,i,j,tmp},lista=l;

For[i=2,i<=Length[lista],i++,

tmp=lista[[i]];j=i;

While[lista[[j-1]]>tmp,lista[[j]]=lista[[j-1]];j--];

lista[[j]]=tmp;] ;

Return[lista]]



7

Sada puštamo da nam indeks i redom prolazi listom, od drugog do zadnjeg elementa. U

svakom i-tom koraku pamtimo element na poziciji i, tj. tmp=i. Za svako fiksno i, druga

varijabla j kreće od i, i sve dok je element na poziciji j-1 veći od tmp elementi sa pozicije j-i

idu na poziciju j, nakon čega dekrementiramo j i ponavljamo - sve dok je element na poziciji

j-1 veći od tmp ....

Nakon toga umećemo element tmp na definisano mu mjesto , tj. lista[[j]]=tmp. Nakraju, funkcija vraća sortiranu listu Return[lista].

Analiza i testiranje

Testiranje na nesortiranim listama dužine 10, 100, 200, 400, 500 i 1000 daje sljedeće

rezultate:

10 0.

100 0.016

200 0.078

400 0.328

500 0.531

1000 2.219 što grafički možemo predstaviti na sljedeći način:

200 400 600 800 1000Broj elemenata

0.5

1

1.5

2

Vrijeme Insert sort

Test na sortiranim listama je puno bolji, za razliku od Selection-Sort. Rezultati se sljedeći:

10 0.

100 0.200 0.

400 0.016

500 0.

1000 0.016

Iako ću na kraju ovo rada uporediti sve algoritme, ovdje ću uporediti Selction-sort i Insert-

Sort. U pitanju su iste liste, pa pogledajmo tablearni pregled (desno Selection-sort, lijevo

Insert-sort):



8

10 0.

100 0.016

200 0.094

400 0.437

500 0.656

1000 2.594

10 0.

100 0.016

200 0.078

400 0.328

500 0.531

1000 2.219 Grafički ću sada predstaviti obje tabele u jednom koordinatnom sistemu.

200 400 600 800 1000

0.5

1

1.5

2

Selecion Sort i Insret Sort

Insert

sort

Selection

sort

Algoritmi sortiranja

Odavdje očito slijedi da je Insert-sort brži od Selection-sorta na nesortiranim, a pogotovo na

sortiranim listama.

Merge-sortDo sada smo samo vidjeli iterativne algoritme sortiranja.

Sada je red na jedan rekurzivni algoritam, koji se koristi tehnikom podijeli pa vladaj.

Merge-Sort uzima kao input jednu listu i vraća listu sortiranih elemenata te liste. Radi tako što

od originalne liste napravi dvije liste, otprilike podjednake dužine, te ponovo sebe pozove na

te obje liste . Rekurzija se zaustavlja kada dobijemo listu dužine 1.

Nakon što sve svedemo na skup lista dužine jedan, spajamo ih ponovo, na pametan način, tj.sortirano.

Pseudo kod je sljedeći:



9

Implementacija u Mathmatici ovog pseudi koda izlgeda ovako:

Objasnimo prethodno.

Prvo ispitujemo da li je proslijeđena lista dužine (manje ili) jednaka 1, ako jeste vraćamo tu

istu listu, jer je lista dužine 1 zapravo sortirana.

Ako nije, onda datu listu dijelimo skoro na pola funkcijom Floor , i time definišemo varijablu

sredina: sredina=Floor[Length[m]/2].Zatim definišemo dvije liste, lijevo i desno, pri čemu u lijevo idu elementi od 1 do sredine,

MergeSort[m_]:=Module[{lijevo,desno,rezultat,i},

If[Length[m]<=1,m,

sredina=Floor[Length[m]/2];lijevo=Table[0,{sredina}];desno=Table[0,{Length[m]-sredina}];

For[i=1,i<=sredina,i++,lijevo[[i]]=m[[i]]];For[i=1,i<=(Length[m]sredina),i++,desno[[i]]=m[[i+sredina]]];

lijevo=MergeSort[lijevo];desno=MergeSort[desno];

rezultat=Merge[lijevo,desno];Return[rezultat]

]]



10

For[i=1,i<=sredina,i++,lijevo[[i]]=m[[i]]]

a u desno elementi od sredine do kraja:

For[i=1,i<=(Length[m]-sredina),i++,desno[[i]]=m[[i+sredina]]].

Sada smo kompletnu ulaznu listu m prebacili u lijevo i desno.

Kako je ovo rekurzivni algoritam, ostaje da na ovako dobijene liste pozovemo istu funkciju:lijevo=MergeSort[lijevo]desno=MergeSort[desno]

te ih nakon toga spajamo funkcijom Merge u jednu listu rezultat , što će i biti vraćeno iz

funkcije: Return[rezultat].

Funkcija Merge

Algoritam je napravljen na takav način da funckija Merge samo dobija ve ć sortirane liste daspoji. Pseudo kod za funkciju Merge je:

što se lahko prevodi u kod programa Mathematica:

Merge[lijevo_,desno_]:=Module[{i,j,k,rezultat},i=1;j=1;k=1;rezultat=Table[0,{Length[lijevo]+Length[desno]}];

While[(i<=Length[lijevo])&&(j<=Length[desno]),If[lijevo[[i]]<=desno[[j]],rezultat[[k]]=lijevo[[i]];i++;k++,rezultat[[k]]=desno[[j]];j++;k++]

];While[j<=Length[desno],rezultat[[k]]=desno[[j]];j++;k++];While[i<=Length[lijevo],rezultat[[k]]=lijevo[[i]];i++;k++];

Return[rezultat]]



11


Algoritram Merge-sort testiran na nesortiranim listama dužine 10, 100, 200, 400, 500 i 1000

daje sljedeće rezultate:

10 0.100 0.062

200 0.11

400 0.281

500 0.312

1000 0.688 čiji je grafički prikaz:

200 400 600 800 1000

Broj elemenata

0.1

0.2

0.3

0.4

0.5

0.6

Vrijeme MergeSort

Test na sortiranim listama daje sljedeće rezultate (lijevo nesortirano, desno sortirano):

10 0.

100 0.062

200 0.11

400 0.281

500 0.312

1000 0.688

10 0.

100 0.062

200 0.125

400 0.234

500 0.25

1000 0.641

Kako je Insert-Sort brži od Selection-Sorta, uporedimo i Merge-Sort sa Insert-Sort (za

nesortirane liste) (lijevo Insert-Sort, desno merge sort):

10 0.

100 0.016

200 0.078

400 0.328

500 0.531

1000 2.219

10 0.

100 0.062

200 0.11

400 0.281

500 0.312

1000 0.688

Vidimo da je Merge-Sort puno brži od Insert-Sort kako veličina liste raste, što se vidi i

grafički:



12

200 400 600 800 1000

0.2

0.4

0.6

0.8

1

1.2

1.4

Merge Sort i Insret Sort

Merge

sort

Insert

sort


Dakle, za sada je Merge-Sort najefikasniji.

Quick-SortQuickSort je još jedan „ Podijeli pa osvoji“ algoritam za sortiranje. QuickSort je sortiranjekomparacijom.Pseudo kod najbolje opisuje rad algoritma - ovo je bio najprimitivniji oblik quicksorta:

Dakle, vidimo iz pseudo koda da QickSort odabere jedan element iz liste – pivot , a zatim

dijeli ulaznu listu na tri liste: lijevo, desno, isto. Elementi liste manji od pivota smještaju se u

lijevo, elementi veći od pivota idu desno, a elementi isti kao pivot smještaju se u isto.

Zatim slijedi rekurzivno pozivanje QucikSort na liste lijevo i desno, dok je lista isto

konstantna – sortirana lista, pa na nju ne pozivamo. Na kraju spajamo sve tri sortirane liste

ovim redom: lijevo, isto, desno.

Problem je što, koristi jako puno memorije – svaki put zauzima 3 nove liste.



13

Također je izbor pivota jako bitna stvar. Možemo ga birati, recimo, kao prvi element liste ili

nasumično iz liste.

Implementacija u programu Mathematica, ovako izgleda, prema pseudo kodu:

Prvo ispitujemo da li je dužina lista manja ili jednaka 1, pa ako jeste vraćamo tu istu listu, a

ako nije, definišemo tri liste i pivot .

Pivot odabiremo nasumično, koji, logično, mora biti prirodan broj od 1 do dužine liste: pivot=m[[Random[Integer,{1,Length[m]}]]].

Ovaj dioFor[i=1,i<=Length[m],i++,

If[m[[i]]<pivot,lijevo=Append[lijevo,m[[i]]],If[m[[i]]>pivot,desno=Append[desno,m[[i]]],isto=Append[isto,m[[i]]]]];(*kraj if petlje*)

];radi sljedeće:

promjenljiva i prima vrijednosti od 1 do dužine liste, i za svako i se ispituje sljedeće:

da li je element u ulaznoj listi na poziciji i manji od pivota, pa ako jeste, dodamo ga u listu

lijevo:lijevo=Append[lijevo,m[[i]]]

a ako nije, ispitujemo da li je element u ulaznoj listi na poziciji i veći od pivota, pa ako jeste

dodajemo taj element u listu desno:If[m[[i]]>pivot,desno=Append[desno,m[[i]]]

a ako nije ni to, pa preostaje da je taj element baš jednak pivotu pa ga odmah smještamo u

listu isto: isto=Append[isto,m[[i]]].

QuickSort[m_]:=Module[{i,pivot,lijevo,desno,isto,rezultat},If[Length[m]<=1, Return[m],

lijevo={};desno={};isto={};pivot=m[[Random[Integer,{1,Length[m]}]]];For[i=1,i<=Length[m],i++,If[m[[i]]<pivot,lijevo=Append[lijevo,m[[i]]],

If[m[[i]]>pivot,desno=Append[desno,m[[i]]],isto=Append[isto,m[[i]]]]

]; (*kraj if petlje*)

]; (*kraj for petlje*)

rezultat=Join[{QuickSort[lijevo],isto,QuickSort[desno]}];Return[rezultat]] (*kraj if petlje*)

]



14

Za spajan je listi na kraju, možemo iskoristiti ugrađenu funkciju Join, ili napraviti svoju:

Join[{QuickSort[lijevo],isto,QuickSort[desno]}].

Ostaje još da vratimo sortiranu listu iz funkcije: Return[rezultat].


Algoritram Quick-Sort testiran na nesortiranim listama dužine 10, 100, 200, 400, 500 i 1000

daje sljedeće rezultate:

10 0.

100 0.032

200 0.031

400 0.109

500 0.157

1000 0.296

Grafički predstavljena prethodna tabela, izgleda:

200 400 600 800 1000Broj elemenata

0.05

0.1

0.15

0.2

0.25

0.3

Vrijeme

QuickSort

nesortirana

lista

Kada uzmemo soritranu listu i primjenimo QuickSort, rezultati su sljedeći (lijevo sortirana,

desno nesortirana):

10 0.

100 0.031

200 0.047

400 0.094

500 0.125

1000 0.265

10 0.

100 0.032

200 0.031

400 0.109

500 0.157

1000 0.296

Iz ovih tablela se zaključuje brzina QuickSorta na soriranim i nesortiranim listama, i vidimo

da je malo brži na sortiranim listama.

Po pitanju sortiranih listi, zaključujemo da je InsertSort najbrži od ovih algoritama.



15

Ostaje da QuickSort uporedimo sa MergeSort koji je bio najbrži od prethodnih algoritama

sortiranja.

Kako se radi o istim listama koje se sortiraju u oba algoritma, zaključak će biti krajnje realan.

Rari preglednosti, prvo ću navesti tabelarne rezultate oba algoritma. Radi se o nesortiranim

listama. Lijevo je MergeSort, desno QuickSort.

10 0.

100 0.062

200 0.11

400 0.281

500 0.312

1000 0.688

10 0.

100 0.032

200 0.031

400 0.109

500 0.157

1000 0.296

Kako je u svakoj navedenoj listi QuickSort brži, zaključujemo da je QuickSort najbrži od

navedenih algoritama. Slijedi grafički pregled ovih algoritama:

200 400 600 800 1000

0.1

0.2

0.3

0.4

0.5

0.6

0.7

Merge Sort i Quick Sort

Merge

sort

Quick

sort




16

200 400 600 800 1000

0.2

0.4

0.6

0.8

1

1.2

Pregled

algoritama

Merge

sort

Quick

sort

Insert

sort

Selec .

sort


Za kraj, navodim grafički pregled svih obrađenih algoritama u jednom koordinatnom sistemu:

algoritmi sortiranja - wolfram mathematica

Documents