BUBBLE SORT (o metoda de interschimbare)

void bubblesort(int *a,int n) { int i,j,aux; for(i=n-1;i>0;i--) for(j=0;j<i;j++) if(a[j]>a[j+1]) { aux=a[j]; a[j]=a[j+1]; a[j+1]=aux; } }

Metoda bulelor const n compararea ai cu ai+1; dac ordinea e bun se compar ai+1 cu ai+2; dac ordinea nu e bun se interschimb ai cu ai+1 i apoi se compar ai+1 cu ai+2. Dup prima parcurgere a vectorului, pe ultima poziie ajunge elementul avnd valoarea cea mai mare, dup a doua parcurgere ajunge urmtorul element . a. m. d. Timpul de prelucrare este de ordinul O(n2). SELECTION SORT (metoda de sortare prin selectie directa)
void selectionsort(int *a,int n) { int i,j,min,aux,index; for(i=0;i<n;i++) { min=a[i]; index=i; for(j=i+1;j<n;j++) if(a[j]<min) { min=a[j]; index=j; } aux=a[i]; a[i]=a[index]; a[index]=a[i]; } }

Sortarea prin selecie direct const n urmtoarele: se afl minimul aj dintre a0, a1, ..., an-1 i se aduce pe poziia zero n vector prin interschimbarea a0 cu aj; apoi procedeul se repet pentru a1, a2, ..., an-1 . a. m. d. Timpul de prelucrare este de ordinul O(n2).

COUNTING SORT (sortare prin numarare)

void countingsort(int *a,int n) { int i,j; int *c=(int*)calloc(n,sizeof(int)); for(i=0;i<n;i++) for(j=0;j<n;j++) if(a[j]<a[i]) c[i]++; for(i=0;i<n;i++) b[i]=a[i]; for(i=0;i<n;i++) a[c[i]]=b[i]; free(b);free(c); }

Metoda sortrii prin numrare const n gsirea pentru fiecare element a[i], a numrului de elemente din vector, mai mici ca el. Numerele obinute sunt memorate ntr-un vector c; elementele vectorului de sortat a, sunt iniial atribuite vectorului b. Pe baza vectorului c, elementele lui b vor fi aranjate n vectorul a. Dezavantajul metodei const n utilizarea a doi vectori de lucru. Timpul de prelucrare este de ordinul O(n2). n programul prezentat la paragraful 2.6., funcia sort_numrare red algoritmul de mai sus. INSERTION SORT (sortare prin inserare)
void insertionsort(int *a,int n) { int i,j,aux,k; for(i=1;i<n;i++) { for(j=i-1;j>=0;j--) if(a[j]<=a[i]) break; aux=a[i]; for(k=i;k>j+1;k--) a[k]=a[k+1]; a[j+1]=aux; } }

Sortarea prin inserare const n urmtoarele: Fie secvena a0 < a1 < a2 ... < aj-1. Inserarea elementului aj n aceast secven const n compararea lui aj cu aj-1, aj-2 ... pn cnd se ajunge la ai < aj; se insereaz aj dup ai, cu meniunea c n prealabil elementele aj-1, aj-2, ..., ai+1 au fost deplasate spre dreapta cu o poziie. Metoda care procedeaz ntocmai se numete inserare direct. Metoda inserrii binare const n cutarea binar a locului unde trebuie inserat elementul aj, avnd n vedere c secvena a0, a1, ..., aj-1 este ordonat cresctor.

SHELL SORT (sortare prin inserare)

void shellsort(int *a,int n) { int i,j,aux,p,k,step=n/2; while(step>0) { for(p=0;p<step;p++) { for(i=p+ste[;i<n;i+=step) for(j=i-step;j>=0;j-=step) if(a[j]<=a[i]) break; aux=a[i]; for(k=i;k>j+step;k-=step) a[k]=a[k-step]; a[j+step]=aux; } step=step/2; } }

Tot din categoria inserrii face parte i metoda shell. Pentru a explica metoda se introduce noiunea de h-sortare. Numim h-sortare, sortarea prin inserare direct a urmtoarelor secvene: a0, ah, a2h, .... a1, a1+h, a1+2h, .... . . . ah, a2h, a3h, .... h este numit increment. Metoda shell const n alegerea unui numr de k incremeni h1 > h2 > h3 > ... > hk = 1 i de a face o h1 sortare, urmat de o h2 sortare . a. m. d., n final o 1 sortare. Performaele metodei sunt strns legate de alegerea incremenilor. n exemplul din paragraful 2.6., funcia sort_inserare_direct red algoritmul de inserare direct, iar funcia shell_sort red algoritmul metodei shell. Timpul de prelucrare n cadrul metodei de inserare direct este de ordinul O(n2), iar al metodei shell de ordinul O(n *lnn). De asemenea timpul de prelucrare n cadrul metodei de inserare prin cutare binar este de ordinul O(n *lnn). MERGE SORT (sortare prin interclasare)
void merge(int *v,int p,int q,int r) { int *vp=(int *)malloc((r-p+1)*sizeof(int)); int i=p,j=q+1,k=0,s; while(i<=q && j<=r) { if(v[i]<v[j]) { vp[k]=v[i]; i++; k++;

} else { vp[k]=v[j]; j++; k++; } } if(i<q) for(s=0;s<q-i;s++) vp[k+s]=v[i+s]; else for(s=0;s<r-j;s++) vp[k+s]=v[j+s]; for(s=0;s<r-p;s++) v[p+s]=vp[s]; } void mergesort(int *v,int p,int r) { if(p==r) return; int q=(p+r)/2; mergesort(v,p,q); mergesort(v,q+1,r); merge(v,p,q,r); }

Metoda sortrii prin interclasare a fost prezentat n cadrul lucrrii nr. 10, drept exemplificare a metodei de elaborare a algoritmilor Divide et Impera QUICKSORT (sortare prin interschimbare)
int partition(int *a,int l,int r) { int index=rand()%(r-l+1)+1; int pivot=a[index]; int i=l,j=r,aux; while(i<=j) { while(a[i]<pivot) i++; while(a[j]>pivot) j--; if(i<=j) { aux=a[i]; a[i]=a[j]; a[j]=aux; i++; j--; } } return i; } void quicksort(int *a,int l,int r) { if(l>=r) return; int i=partition(a,l,r); quicksort(a,l,i-1); quicksort(a,i,r); }

Sortarea rapid quicksort a fost creat de Hoare i folosete metoda Divide Et Impera.

Principiul metodei este urmtorul: se selecteaz un element din tablou numit pivot i se rearanjeaz vectorul n doi subvectori, astfel nct cel din stnga are toate elementele mai mici dect pivotul, iar cel din dreapta mai mare ca pivotul. Procedeul se reia n subtabloul din stnga i apoi n cel din dreapta . a. m. d. Procedeul se termin cnd se ajunge cu pivotul n extremitatea stng i respectiv dreapt a tabloului iniial. Timpul de prelucrare a metodei quicksort este de ordinul O(n* lnn).
RADIX SORT
typedef struct queue{ int size; // dimensiunea cozii int* head; // adresa de inceput a vectorului }queue; void radixsort(int* a,int n){ queue Q[2],QP[2]; // cele 4 cozi (2 curente, 2 vechi) for(int i=0;i<2;i++) { // alocarea spatiului pentru cozi Q[i].size=0; Q[i].head=(int*)malloc(n*sizeof(int)); QP[i].size=0; QP[i].head=(int*)malloc(n*sizeof(int)); } for(int i=0;i<n;i++) // depunerea elementelor in prima coada Q[0].head[i]=a[i]; Q[0].size=n; for(int i=0;i<16;i++) { // intregi reprezentati pe 16 biti for(int j=0;j<2;j++) { // parcurgerea celor 2 cozi for(int k=0;k<Q[j].size;k++) { int elem=Q[j].head[k];int bit=(elem>>i)%2; int size=QP[bit].size; // dim. curenta QP[bit].head[size]=elem; // inserare elem QP[bit].size++; // actualizare dimensiune } } } for(int i=0;i<16;i++) { // intregi reprezentati pe 16 biti int *q0=Q[0].head, *q1=Q[1].head; // interschimbare cozi Q[0]=QP[0];Q[1]=QP[1]; QP[0].head=q0;QP[1].head=q1; QP[0].size=0;QP[1].size=0; // golirea cozilor } int i=0; for(int j=0;j<2;j++){ // copierea elementelor in vector for(int k=0;k<Q[j].size;k++){ a[i]=Q[j].head[k]; i++; }} free(Q[0].head);free(Q[1].head); // eliberarea celor 4 cozi folosite free(QP[0].head);free(QP[1].head); }