algoritmi sortiranja

7/29/2019 Algoritmi Sortiranja

http://slidepdf.com/reader/full/algoritmi-sortiranja 1/57

Složenost algoritama isortiranje



Algoritam

Algoritam je opis za

rešavanje nekog problema.

Reč dolazi iz prezimenapersijskog matematičara Al

Horezmija. Algoritam je bio izraz koji

opisuje način računanjadecimalnim brojevima

uvedenim oko 1600. godine

u Evropi.Dijagram toka se često koriste za

predstavljanje algoritma



O nastanku

Algoritam je u matematiku uveo arapskimatematičar Muhamed Al Horezmi.

Napisao je knjigu Al Horezmi o indijskoj veštini računanja gde u arapskumatematiku uvodi indijske cifre i decimalni

brojni sistem. Ova knjiga biva kasnije prevedena na

latinski kao Algoritmi de numero indorum.

Od lošeg latinskog prevoda njegovogprezimena i potiče reč algoritam, i dugo je

označavala postupak za račun sadecimalnim brojnim sistemom (i indijskimodnosno, kako se kasnije pričalo, arapskimciframa).



Algoritam

U novije vreme, algoritam je pojam koji se gotovoisključivo vezuje za informatiku i, mada ne postoji jedinstvena opšteprihvaćena definicija,podrazumeva se da je u pitanju nekako opisana

procedura za obavljanje posla. U tu svrhu se definišu algoritamski jezici-

formalizovani jezici kojima se relativno lako opisujupostupci rešavanja problema predstavljenihalgoritmom, npr. programski jezici Algol, Fortran i

Kobol. U matematičkoj logici je algoritam generalizovan

pojam i odnosi se na postupak za postupnopretvaranje nizova znakova.



Definicija

Algoritam je konačna i precizno definisana procedura, niz dobrodefinisanih pravila, kojom se ulazne vrednosti transformišu uizlazne, ili se opisuje izvršavanje nekog postupka.

Danas se reč algoritam često vezuje za pojam računarstva madauopšteno algoritam možemo smatrati kao uputstvo kako rešitineki zadatak ili problem.

Uputstvo može sadržati korake koji se ponavljaju više puta ilikorake kada treba doneti neku odluku, na osnovu nekogkriterijuma.

Dobro uputstvo predviĎa i postupak kada nisu svi uslovi ispunjeni Korektno izvršavanje svakog koraka ne rešava zadatak ako je

algoritam bio pogrešan.



Definicija

Različiti algoritmi mogu rešiti isti problem različitimnizom postupaka uz manje ili više napora, za kraćeili duže vreme. S obzirom da je rezultat isti, algoritmise mogu porediti po svojoj efikasnosti, brzini ili

kompleksnosti. Algoritmi mogu biti prikazani ili realizovani na više

načina: prirodnim jezikom (razumljiv samo govornicima tog jezika)

Grafički, dijagramom toka (blok-dijagramom) ili strukturnim

dijagramima ili tekstualno - pseudokom, veštačkim precizno definisanim

jezikom koji liči na programski jezik odgovarajućim programskim jezikom.



Primeri algoritama iz svakodnevnog života

Primer algoritma iz svakodnevnog života je kuvanje čaja. Svakikorak pripremanja čaja mora biti izvršen pravilno kako bi semoglo preći na sledeći i u konačnom vremenu dobiti skuvan čaj.

1. Uzeti lonče i sipati vodu.2. Uključiti ringlu.

3. Sačekati dok voda ne proključa.4. Kad voda proključa, skinuti lonče i isključiti ringlu.5. Staviti kesicu čaja u lonče.6. Po želji, dodati kašiku šećera, mleko ili limun.7. Sipati čaj u šolju.

Iz ovog jednostavnog primera može se videti postupnost i

konačnost algoritma. Naime, nema previše koristi od algoritmakoji se nikada ne završava ili algoritma čije se naredbe izvodenepredvidljivo ili im je rezultat nepredvidljiv.



Primeri algoritama

Primer kompleksnijeg algoritma je Euklidov

algoritam za odreĎivanje najvećegzajedničkog delioca:

1. Podeliti broj a brojem b pri čemu se dobija količnik c i ostatak r 2. Broj a uzima vrednost broja b

3. Broj b uzima vrednost r

4. Ponavljati sve dok ostatak r ne bude jednak 0. Najveći zajednički delilac je

trenutna vrednost broja a



Istorija

Prvi algoritam koji se može smatrati procedurom čija je namena računna automatskoj mašini je napisala Ejda Bajron 1842. godine.

U pitanju je algoritam za odreĎivanje Bernulijevih brojeva na analitičkojmašini Čarlsa Bebidža. Ta mašina nikad nije proradila, ali je njenalgoritam ostavio dubok trag.

Danas se to priznaje kao prvi računarski algoritam, a Ejda Bajron , ledi

Lavlejs, je priznata kao prvi programer u istoriji. U njenu čast je i jedanod najkompleksnijih programskih jezika dobio naziv Ada.

Značajan napredak u formalizaciji uvoĎenja algoritma u matematiku ilogiku je učinio Alan Tjuring u svojim radovima definisanjem Tjuringovemašine.

To je primitivan automat, misaona tvorevina, ali poseduje mogućnost

izvoĎenja nekoliko operacija koje su dovoljne za izvoĎenje skoro svihalgoritama. Čerč-Tjuringova teza tvrdi da se svaki algoritam koji jedobro definisan može izvršiti na takvoj mašini.



Osobine

Algoritmi poseduju sledeće osobine: diskretnost — u odvojenim koracima se izvršavaju

diskretne operacije algoritma koji vode ka konačnom cilju;

rezultativnost — označava sposobnost algoritma da poslekonačnog broja koraka daje izlazne podatke;

determinisanost — za iste ulazne podatke algoritam uvek

generiše iste vrednosti na izlazima i

masovnost — algoritam je primenljiv na veći broj ulaznih

vrednosti.



Složenost algoritama Za rešavanje istog problema se mogu naći različiti

algoritmi. Pitanje: koji koristiti ?

Potrebno je odrediti meru kvaliteta algoritama da bise pri izboru algoritma moglo odrediti koji je bolji.

Meri se količina resursa koje algoritam zahteva da birešio problem.

Dve mere koje se najčešće koriste su vremepotrebno za izvršenje algoritma i prostor potrebanza pohranjivanje ulaznih podataka, meĎurezultata iizlaznih rezultata.



Vremenska i prostorna složenostalgoritma

Mi ćemo se baviti samo vremenskom složenošćualgoritama (češće se koristi u ocenjivanju kvalitetaalgoritma)

Prvi problem kod odreĎivanja vremenske složenosti

algoritma je pronalaženje mere koja ne zavisi od brzineračunara na kojem se algoritam izvodi, već samo osamom algoritmu

Zato se vremenska složenost algoritma ne izražavavremenom potrebnim da algoritam izračuna rezultat, većbrojem elementarnih operacija koje algoritam mora izvestiu proračunu



Vremenska i prostorna složenostalgoritma Svrha: predviĎanje vremena izračunavanja i pronalaženje

efikasnijih algoritama.

Pretpostavke: fiksno vreme dohvatanja sadržaja memorijskelokacije, vreme obavljanja elementarnih operacija

(aritmetičke, logičke, pridruživanje, poziv funkcije) jeograničeno nekom konstantom kao gornjom granicom.

Broj operacija koje algoritam izvodi zavisi od veličine ulaza

Instance problema različitih dimenzija zahtevaju različit broj

operacija. Složenost algoritma nije funkcija samo veličine ulaza, mogu

postojati različite instance iste dužine ulaza, ali različitihsloženosti (različite vrednosti ulaza)



Analize “a priori” i “a posteriori”

izbor skupova podataka za iscrpno testiranje algoritma: ponašanje u najboljem slučaju (best case scenario)

ponašanje u najgorem slučaju (worst case scenario)

prosečno (tipično) ponašanje

a priori trajanje izvoĎenja algoritma (u najgorem slučaju) kao vrednost funkcije

nekih relevantnih argumenata (npr. broja podataka)

a posteriori statistika dobijena merenjem na računaru



procena vremena izvoĎenja, nezavisno odračunara, programskog jezika, prevodioca(compilera)

primeri:

a) x += y; 1

b) for(i = 1; i <= n; i++) { nx += y;

}

c) for(i = 1; i <= n; i++) { n2

for(j = 1; j <= n; j++) {x += y;

}}

Analiza “a priori”



Funkcija složenosti algoritma Uvodi se notacija koja jednostavno opisuje brzinu rasta

složenosti algoritma. Asimptotska ocena rasta funkcije: pri izračunavanju

složenosti aproksimacija se vrši tako da aproksimativnafunkcija koja je jednostavnija od same funkcije složenosti,dobro asimptotski opisuje rast funkcije složenosti.

Ne zanima nas stvarni iznos funkcije složenosti, već samokoliko brzo ta funkcija raste, zanima nas njen red veličine

Primer: vreme izvršavanja Gausovog algoritma zainvertovanje matrice je proporcionalno sa n3, što znači daako se red matrice udvostruči, invertovanje može trajati do 8puta duže



O - notacija

f(n) = O(g(n)) ako postoje dve pozitivne konstante c i n0 takve da

vredi f(n) c g(n) za sve n n0

traži se najmanje g(n) za koje to vredi

drugim rečima, procjenjuje se trajanje kao red veličine odreĎenna osnovu broja podataka n, pomnoženo s nekom konstantom c

primeri:

n3+5n2+77n = O(n3 )

Koliki je posao preneti 1 stolicu iz sale A u salu B?

Koliki je posao preneti n stolica iz A u B?

Koliki je posao preneti n stolica iz A u B, s time da se kod donošenja svake nove

stolice sve do tada donetee stolice u B moraju pomeriti, pri čemu se za

pomeranje stolice u dvorani B ulaže isti trud kao i kod prenosa jedne stolice iz A u

B?

1 + 2 + 3 + 4 + ...+ n = n(n+1)/2 = n2 /2 + n/2 = O (n2 )



O - notacija

analizom ―a priori‖ dobija se vreme izvoĎenja

algoritma O(g(n))

ako je broj izvoĎenja operacija nekog algoritma

zavisi od nekog ulaznog argumenta n oblika

polinoma m-tog stepena, onda je vreme izvoĎenjaza taj algoritam O(nm )

Algoritmi i strukture podataka, FER, 18 / 35



vredi za dovoljno veliko n:

O(1) < O(log n) < O(n) < O(nlog n) < O(n2) < O(n3) < ...< O(2n) < O(n!)

O(1) znači da je vreme izvoĎenja ograničeno konstantom

ostale vrednosti, do predzadnje, predstavljaju polinomna vremena izvoĎenja algoritma

svako sledeće vreme izvoĎenja je veće za red veličine

predzadnji izraz predstavlja eksponencijalno vreme izvoĎenja

algoritmi koji zahtijevaju eksponencijalno vreme mogu biti

nerešivi u razumnom vremenu, bez obzira na brzinu računara

O - notacija

Algoritmi i strukture podataka, FER, 19 / 35



Primer: traženje najvećeg člana u nizu

int maxclan (int A[ ], int n) {

int i, imax;

i = n-1;

imax =n-1; while (i > 0) {

i--;

if (A[i] > A[imax]) imax = i;}

return imax;}

petlja se uvekobavi n-1 puta

O(n)



Primer: traženje zadatog elementa u nizu

int trazi (int A[ ], int x, int n, int i) {

// A-niz, x-trazeni, i-indeks od kojeg se trazi

int ret;

if (i >= n) ret = -1;

else if (A[i] == x) ret = i;else ret = trazi (A, x, n, i+1);

return ret;

}

- vreme izvoĎenja je O(n), ali je donja granica ( 1 ).

U najboljem slučaju u prvom koraku naĎe setraženi član niza, a u najgorem mora pregledatisve članove niza.



Analiza “a posteriori”

•stvarno vreme potrebno za izvođenje algoritma nakonkretnom računalu

#include <sys\timeb.h> // gde je deklarisano

struct timeb {time_t time; // broj sekundi od ponoći, 01.01.1970, UTC

unsigned short millitm; // milisekunde

short timezone; // razlika u minutama od UTC

short dstflag; // <>0 ako je na snazi letnje vreme

};

void ftime(struct timeb *timeptr);



Analiza “a posteriori”

u programu:

Universal Time Co-ordinated (UTC)

novi naziv za Greenwich Mean Time (GMT)

struct timeb vreme1, vreme2; long trajanjems;

ftime (&vreme1);

...ftime (&vreme2);

trajanjems = 1000 * (vreme2.time - vreme1.time) +

vreme2.millitm - vreme1.millitm;



Primeri zavisnosti trajanja od broja

podataka i složenosti n T(n) = n T(n) = n lg(n) T(n) = n2 T(n) = n3 T(n) = 2n

5 0.005 s 0.01 s 0.03 s 0.13 s 0.03 s

10 0.01 s 0.03 s 0.1 s 1 s 1 s

20 0.02 s 0.09 s 0.4 s 8 s 1 ms

50 0.05 s 0.28 s 2.5 s 125 s 13 dana

100 0.1 s 0.66 s 10 s 1 ms 4 x 1013 godina



Što se može rešiti u zadatom vremenu

Vremenska složenost

Veličina najvećeg slučaja problema koji se može rešiti za 1 sat

danas raspoloživim

računarom

100 puta bržim

računarom

1000 puta bržim

računarom

n N1 100N1 1000N1

n2 N2 10 N2 31.6 N2

n3 N3 4.64 N3 10 N3

2n N4 N4+6.64 N4+9.97

3n N5 N5+4.19 N5+6.29



Sortiranje

Sortiranje – jedan od klasičnih nenumeričkihproblema.

Čest problem koji se javlja u obradi podatakabilo samostalno, bilo kao sastavni deosloženijih problema.



Interno sortiranje

Razlikuje se interno sortiranje i sortiranje na

eksternim memorijama.

Interno sortiranje – podrazumeva se situacija gde se

u memoriji računara nalazi vektor x(1), x(2), ... x(n)čije vrednosti su proizvoljni brojevi.

Vektor je potrebno preurediti tako da bude

zadovoljen uslov da je:

x(1)<=x(2)<=...<=x(n) rastuće sortiranje x(1)>=x(2)>=...>=x(n) opadajuće sortiranje



Eksterno sortiranje

Sortiranje na eksternim memorijama- radi se

po pravilu o relativno velikim datotekama čijizapisi sadrže polje ključa i polja podataka, a

problem se sastoji u tome da se zapisidatoteke poreĎaju po rastućim (iliopadajućim) vrednostima ključa.



Najčešće metode sortiranja

Metoda umetanja (Insertion sort )

Metoda zamene suseda (Bubble sort )

Metoda izbora (Selection sort )

Sortiranje po lancima ekvidistantnih zapisa

(Shell sort )

Sortiranje po metodi kupa (Heapsort )

Particijska metoda sortiranja (Quicksort )

Sortiranje spajanjem (Merge sort)



Složenost algoritama za sortiranje

Algoritmi za sortiranje mogu se podeliti u dve

grupe prema složenosti svojih algoritama. O(n) predstavlja algoritam koji ima linearnu

složenost. O(n2), kvadratna složenost.



Složenost algoritama Dve klase algoritama za sortiranje su O(n2), gde

spadaju buble, insertion, selection i shell sort iO(n log n) gde spadaju heap, merge i quick sort.f(n) Tip algoritma

const. konstantan

log2n logaritamski

n linearan

nlog2n linearno-logaritamski

n2 kvadratni

nk (k>2) stepeni

kn (k>1) eksponecijalni

n! faktorijelni

R a

s t u ć a s l o ž e n o s t



Složenost algoritama O(n2 )



Složenost algoritama O(nlog 2n)



Bubble sort

Poredi vrednosti dva susedna elementa i vršizamenu ukoliko je potrebno. Algoritam

ponavlja ovaj proces sve dok ne proĎe kroz

ceo niz a da ne izvrši ni jednu zamenu. Naovaj način veće vrednosti ―isplivaju‖ na krajniza a manje vrednosti ―potonu‖ na početakniza.

za: jednostavnost i lakoća primene.

protiv: velika neefikasnost.



Bubble sort



Bubble sort algoritam

void bubbleSort(int numbers[ ], int array_size){

int i, j, temp;

for (i = (array_size - 1); i >= 0; i--)

{

for (j = 1; j <= i; j++)

{if (numbers[j-1] > numbers[j])

{

temp = numbers[j-1];

numbers[j-1] = numbers[j];

numbers[j] = temp;

}

}}

}



Insertion sort

Ubacuje svaki element na njegovo odgovarajućemesto u finalnom nizu. Najjednostavnija primena

zahteva dva niza – izvorni niz i niz u koji se element

ubacuje. Kako bi se sačuvala memorija, najčešće seradi tako da element koji se trenutno pomera

postavlja iza već sortiranih elemenata i ponavlja sezamena dok se ne postavi na odgovarajuću poziciju.

za: relativno jednostavan i lak za primenu.protiv: neefikasan za velike nizove.



Insertion sort



Insertion sort algoritam

void insertionSort(int numbers[], int array_size){

int i, j, index;

for (i=1; i < array_size; i++)

{

index = numbers[i];

j = i; while ((j > 0) && (numbers[j-1] > index))

{

numbers[j] = numbers[j-1];

j = j - 1;

}

numbers[j] = index;

}}



Selection sort

Radi tako da bira najmanji preostali

nesortirani element u nizu, zatim ga menja sa

elementom na sledećoj poziciji koja treba da

se popuni. za: jednostavan i lak za primenu.

protiv: neefikasan za velike nizove.



Selection sort



Selection sort algoritam

void selectionSort(int numbers[], int array_size){

int i, j;

int min, temp;

for (i = 0; i < array_size-1; i++)

{

min = i;for (j = i+1; j < array_size; j++)

{

if (numbers[j] < numbers[min]) min = j;

}

temp = numbers[i];

numbers[i] = numbers[min];

numbers[min] = temp;}

}



Shell sort

Najefikasniji od O(n2) algoritama aliistovremeno i najsloženiji (Donald Shell,1959.)

Nekoliko puta prolazi kroz niz, sortirajućisvaki put nizove istih dimenzija koristećiinsertion sort . Svaki put prolaskom kroz nizuvećava se niz koji treba sortirati dok to ne

bude ceo niz. za: efikasan za nizove srednje veličine.

protiv: donekle složen algoritam.



Shell sort



Shell sort algoritamvoid shellSort(int numbers[], int array_size)

{

int i, j, increment, temp;increment = 3;

while (increment > 0)

{for (i=0; i < array_size; i++)

{

j = i; temp = numbers[i];

while ((j >= increment) && (numbers[j-increment] > temp))

{numbers[j] = numbers[j - increment];

j = j - increment;

}

numbers[j] = temp;

}

if (increment/2 != 0)

increment = increment/2;

else if (increment == 1)

increment = 0;

else increment = 1;

}

}



Heap sort

za: nerekurzivan, dobar izbor kada je

potrebno sortirati ekstremno velike nizove.

protiv: sporiji od merge i quick algoritama.



Heap sort

H l i



Heap sort algoritamvoid heapSort(int numbers[], int array_size)

{

int i, temp;

for (i = (array_size / 2)-1; i >= 0; i--) siftDown(numbers, i, array_size);

for (i = array_size-1; i >= 1; i--){

temp = numbers[0];

numbers[0] = numbers[i];

numbers[i] = temp;

siftDown(numbers, 0, i-1);

}

}

void siftDown(int numbers[], int root, int bottom)

{int done, maxChild, temp;

done = 0;

while ((root*2 <= bottom) && (!done))

{

if (root*2 == bottom)

maxChild = root * 2;

else if (numbers[root * 2] > numbers[root * 2 + 1])

maxChild = root * 2;

else maxChild = root * 2 + 1;

if (numbers[root] < numbers[maxChild])

{

temp = numbers[root];

numbers[root] = numbers[maxChild];

numbers[maxChild] = temp;

root = maxChild;

}

else done = 1;}

}



Merge sort

Niz koji treba sortirati deli se na dva jednaka delakoji se postavljaju u zasebne nizove. Svaki nizrekurzivno se sortira a zatim se spajaju da bi sedobio finalni sortirani niz.

Najjednostavnija primena ove metode koristi tri niza – po jedan niz za svaku polovinu podataka i jedanniz za sortirane elemente.

za: brže sortira nego heap sort za veće nizovepodataka.

protiv: najmanje dvostruko veći zahtev zamemorijom nego kod drugih metoda sortiranja,rekurzivan.



Merge sort



Merge sort algoritam

void mergeSort(int numbers[], int temp[], int array_size){

m_sort(numbers, temp, 0, array_size - 1);

}

void m_sort(int numbers[], int temp[], int left, int right) {

int mid; if (right > left)

{ mid = (right + left) / 2;

m_sort(numbers, temp, left, mid);

m_sort(numbers, temp, mid+1, right);

merge(numbers, temp, left, mid+1, right);

}

}



Merge sortvoid merge(int numbers[], int temp[], int left, int mid, int right)

{int i, left_end, num_elements, tmp_pos;

left_end = mid - 1;

tmp_pos = left;

num_elements = right - left + 1; while ((left <= left_end) && (mid <= right))

{

if (numbers[left] <= numbers[mid])

{

temp[tmp_pos] = numbers[left];tmp_pos = tmp_pos + 1; left = left +1;

}

else {

temp[tmp_pos] = numbers[mid];

tmp_pos = tmp_pos + 1; mid = mid + 1;

}

}



Merge sort while (left <= left_end)

{

temp[tmp_pos] = numbers[left];

left = left + 1;

tmp_pos = tmp_pos + 1;

} while (mid <= right)

{

temp[tmp_pos] = numbers[mid];

mid = mid + 1;

tmp_pos = tmp_pos + 1;}

for (i=0; i <= num_elements; i++)

{

numbers[right] = temp[right];

right = right - 1;

}

}



Quick sort

Algoritam vrlo jednostavan u teoriji, ali veoma jeteško pretočiti ga u kod.

Rekurzivni algoritam čine četiri koraka: Ako niz ima jedan ili manje elemenata za soritiranje, kraj.

Odaberi jedan element u nizu za pivot (za to se najčešćekoristi krajnje levi element niza).

Podeli niz na dva dela – u jednom su elementi veći odpivota a u drugom elementi manji od pivota.

Rekurzivno ponavljaj algoritam za obe polovine originalnogniza.

za: izuzetno brz.protiv: veoma složen algoritam, rekurzija.



Quick sort



Quick sort algoritam

void quickSort(int numbers[], int array_size){

q_sort(numbers, 0, array_size - 1);

}

void q_sort(int numbers[], int left, int right)

{

int pivot, l_hold, r_hold;

l_hold = left; r_hold = right; pivot = numbers[left];

while (left < right) {

while ((numbers[right] >= pivot) && (left < right))

right--;

if (left != right) {

numbers[left] = numbers[right]; left++; } while ((numbers[left] <= pivot) && (left < right))

left++;

k l



Quick sort algoritam

if (left != right) {numbers[right] = numbers[left];

right--;

}

}

numbers[left] = pivot;

pivot = left;

left = l_hold;

right = r_hold;

if (left < pivot)

q_sort(numbers, left, pivot-1);

if (right > pivot)

q_sort(numbers, pivot+1, right);

}

algoritmi sortiranja

Documents