Tehnici de sortare avansat a tablourilor Structuri de

Tehnici de sortare avansată a tablourilor Structuri de date şi algoritmi -laborators. l. dr. ing. Ciprian-Bogdan Chirilă Universitatea Politehnica Timişoara 2014

Cuprins n n Sortarea prin partiţionare - Quicksort Bin. Sort Radix. Sort Concluzii

Sortarea prin partiţionare - Quicksort n n Se alege un element oarecare al tabloului tab[k] pe care-l notăm cu x; Se parcurge tabloul de la stânga la dreapta până se găseşte primul element tab[i]>x; n Se parcurge tabloul de la dreapta la stânga până se găseşte primul element tab[j]<x;

Sortarea prin partiţionare - Quicksort n n n Cele două elemente astfel găsite tab[i] şi tab[j] se interschimbă; Se reia parcurgerea tabloului din punctele rămase până se găsesc alte două elemente care trebuiesc interschimbate; Procesul se încheie când cele două parcurgeri se întâlnesc;

Sortarea prin partiţionare - Quicksort n Tabloul este compus din două partiţii: n n n Cea din stânga cu elemente mai mici decât x; Cea din dreapta cu elemente mai mari decât x; Procedura se aplică pe cele două partiţii obţinute până se ajunge la partiţie de un singur element;

Quicksort – cod 1 void Sortare. Quicksort. Recursiv(int s, int d, int *tab, int n) { int i, j, x, w; i=s; j=d; x=tab[(s+d)/2]; do { while(tab[i]<x) i++; while(tab[j]>x) j--; if(i<=j) { w=tab[i]; tab[i]=tab[j]; tab[j]=w; i++; j--; } } while(i<=j); if(s<j)Sortare. Quicksort. Recursiv(s, j, tab, n); if(d>i)Sortare. Quicksort. Recursiv(i, d, tab, n); }

Quicksort – cod 2 void Sortare. Quicksort(int *tab, int n) { Sortare. Quicksort. Recursiv(0, n, tab, n); }

Quicksort – demo 1 0 1 2 3 4 5 6 47 78 92 50 33 21 19 47 19 92 50 33 21 78 47 19 21 50 33 92 78 47 19 21 33 50 92 78 19 47 21 33 50 92 78 19 33 21 47 50 92 78

Quicksort – demo 2 0 1 2 3 4 5 6 19 33 21 47 50 92 78 19 21 33 47 50 78 92 19 21 33 47 50 78 92

Binsort n n Este metodă de sortare care ţine cont de valorile cheilor; Se poate aplica în cazul în care cheile sunt valori de tip întreg cuprins în intervalul 1. . N ; Se parcurge tabloul tab verificându-se dacă elementul tab[i] are cheia j egală cu i ; Dacă j!=i atunci se interschimbă elementele tab[i] şi tab[j] ;

Binsort - cod void Binsort(int *tab, int n) { int i, temp; for(i=0; i<n; i++) { while(tab[i]!=i) { temp=tab[i]; tab[i]=tab[temp]; tab[temp]=temp; } } }

Binsort – demo 1 0 1 2 3 4 5 6 7 i=0 7 3 1 2 0 5 4 6 i=0 6 3 1 2 0 5 4 7 i=1 6 2 1 3 0 5 4 7 i=2 6 1 2 3 0 5 4 7

Binsort – demo 2 0 1 2 3 4 5 6 7 i=4 6 1 2 3 0 5 4 7 i=4 0 1 2 3 6 5 4 7 i=6 0 1 2 3 4 5 6 7

Radixsort n n Cheile de sortate sunt văzute ca numere reprezentate într-o anumită bază (radix R=2); Cheile cu primul bit 0 sunt trecute în faţa celor care au primul bit 1; Se aplică acceaşi metodă pentru bitul următor, etc. . . ; Procesul se desfăşoară ca la metoda Quicksort;

Radixsort – cod 1 void Radixsort. Recursiv(int s, int d, int b, int *tab, int n) { int i, j, t; if((s<d) && (b>=0)) { i=s; j=d; do { while((Biti(tab[i], b, 1)==0) && (i<j)) i++; while((Biti(tab[j], b, 1)==1) && (i<j)) j--; t=tab[i]; tab[i]=tab[j]; tab[j]=t; } while(i<j); if(Biti(tab[d], b, 1)==0) j++; Radixsort. Recursiv(s, j-1, b-1, tab, n); Radixsort. Recursiv(j, d, b-1, tab, n); } }

Radixsort – cod 2 void Radixsort(int *tab, int n) { Radixsort. Recursiv(0, n-1, sizeof(int)*8 -2, tab, n); }

Radixsort – cod 3 int Biti(int x, int k, int j) { int i; int doik=1; int doij=1; for(i=0; i<k; i++) doik=doik*2; for(i=0; i<j; i++) doij=doij*2; return (x/doik)%doij; }

Radixsort – demo 1 7 8 2 4 1 0 9 7 3 0111 1000 0010 0100 0001 0000 1001 0111 0011 7 3 2 4 1 0 9 7 8 0111 0010 0100 0001 0000 1001 0111 1000 7 3 2 4 1 0 7 9 8 0111 0010 0100 0001 0000 0111 1000

Radixsort – demo 2 7 3 2 4 1 0 7 9 8 0111 0010 0100 0001 0000 0111 1000 0 3 2 4 1 7 7 9 8 0000 0011 0010 0100 0001 0111 1001 1000 0 3 2 1 4 7 7 9 8 0000 0011 0010 0001 0100 0111 1000