ALGORITME i=i-1;

PJESA E PARE }

A[i+1]=k;

KOMPLEKSITETI->eshte nje funksion numerik }}

qe perfaqeson varesine e kohes qe i duhet
algoritmit per tu ekzakutuar nga permasa e
problemit.
3.BUBBLE SORT-On2-bredh te gjithe el
BIG O->me e lehte dhe me me shum interes qe do te renditen duke krahasur cdo 2 cifte
te arsyetohet per kufijt e poshtem dhe te el dhe u nderron vendin el t ciftit qe sjan n
siperm te kohes se ekz te algoritmit. renditjen e duhur

1.Algoritme te Renditjes: zhvendoset el me i madh

ne te djathte.perfundon kur ska me el qe
1.SELECTION SORT-On2-kerkon min te duhet nderruar vendi.
parenditur me te dhenat per ta renditur dhe
e zhvendos ne fund te pjeses se renditur void bubble_sort(int A[],int n){

void selection_sort(int A[],int n){ int tmp;

int min; for(int i-0;i<0;i++){

for(int i=0;i<n;i++){ for(int j=0;j>=i+1;j--){

min=i; if(A[j]<A[j-1]){

for(int j=i+1;j<n;j++){ tmp=A[j];

if(A[j]<A[min]) A[j]=A[j-1];

min=j; A[j-1]=tmp;

int tmp=A[i]; }}}}

A[i]=A[min]; 4.MERGE-SORT-On-tab 1 dim ndahet

ne 2 nentab te tjera me permasa sa gjysma
A[min]=tmp; e tab kryesore.Renditen te dyja ne menyre
rekursive dhe bashkohen(merge)
}}}
2 nentab e renditura ne 1
tab t renditur.

2.INSERTION SORT-On2-me tabele- merge_sort(int A[],int fillim,int fund){

vendos el qe trajton sekuencen e pjesshme
te renditur te el derisa ti trajtoj te gjitha el int mes;

void insertion_sort(int A[],in n){ if(fillim<fund){

for(int i=0;i<n;i++){ mes=(fillim+fund)/2;

int k=A[j]; merge_sort(A,fillim,mes);

int i=j-1;
merge_sort(A,mes+1,fund);
while((i>0)&&(A[i]>k)){
merge(A,fillim,mes,fund);
A[i+1]=A[i];
}}
 PS:qe te renditet e gjithe tabela A l=l+1;
duhet te therrite merge_sort(A,0,n-1) ku n
eshte nr i el te tab A. m=m+1;

merge(int A[],int fillim,int mes,int }

fund){
int B[fund+1];//perdorim nj tab t
parakohshme v qe do mbaj te dhenat e
renditura
for(int i=fillim;i<fund;i++)
B[i]=A[i];
int k=fillim;//iniciohet per te
trajtuar el e nent A[fillim..mes]
5.QUICK SORT-perdoret per te renditur
1 liste me n element.zgjedh nje el p n
list,rast i mir eshte mesorja ose pivoti.
perdor dy indekse
l qe mess vleren fillestare 0 dhe indeksin h
qe merr vlere fillestare n-1.
quicksort(int S[],int l,int h){
int p;

int l=mes+1;//iniciohet per te if((h-l)>0){

trajtura el e nentab A[mes+1..fund]
p=particione(s,l,h);
int m=0;
quicksort(s,l,p-1);
while(k<=mes && l<=fundi){
quicksort(s,p+1,h);
if(B[k]<=B[l]){
}
A[m]=B[k];//per
cdo hap A[k] dhe A[l] dhe el me i vgl }
vendoset i pari n tab B
int particione (int S[],int l,int h){
k=k+1;
int i;
}
int p;
else{
int pozpivot;
A[m]=B[l];
p=h;
l=l+1;
pozpivot=l;
}
for(i=l;i<h;i++){
m=m+1;
if(S[i]<S[p]){
}

while(k<=mes){ swap(&S[i],&S[pozpivot]);

A[m]=B[k]; pozpivot++;

k=k+1; }}

m=m+1; swap(&S[p],&S[pozpivot]);

} return (pozpivot);

while(l<=fundi){ }

A[m]=B[l];
 6.BINARY SEARCH-alg i shpejte per te if(A[mes]>element)
kerkuar 1 el ne nje liste te renditur
return
int kerkim_binar(list A,int element,int (kerkim_binar(A,element,fill,mes-1));
fill,int fund){
else
int mes;
return
if(fill>fund) return -1; (kerkim_binar(A,element,mes+1,fund));

mes=(fill+fund)/2; }

if(A[mes]==element) return
mes;