Tehnici de sortare avansat ă a tablourilor

1. Tehnici de sortare avansată a tablourilor Structuri de date şi algoritmi 1 -laborator- s.l. dr. ing. Ciprian-Bogdan Chirilă Universitatea “Ioan Slavici” Timişoara 2012

2. Cuprins • Sortarea prin partiţionare - Quicksort • BinSort • RadixSort • Concluzii

3. Sortarea prin partiţionare - Quicksort • 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; • Se parcurge tabloul de la dreapta la stânga până se găseşte primul element tab[j]<x;

4. Sortarea prin partiţionare - Quicksort • 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;

5. Sortarea prin partiţionare - Quicksort • Tabloul este compus din două partiţii: • 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;

6. Quicksort – cod 1 void SortareQuicksortRecursiv(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)SortareQuicksortRecursiv(s,j,tab,n); if(d>i)SortareQuicksortRecursiv(i,d,tab,n); }

7. Quicksort – cod 2 void SortareQuicksort(int *tab, int n) { SortareQuicksortRecursiv(0,n,tab,n); }

8. Quicksort – demo 1 0 1 2 3 4 5 6 4778 92 50 33 21 19 47 19 9250 33 2178 47 19 21 50 33 92 78 4719 21 33 50 92 78 4719 21 33 50 92 78 19 472133 50 92 78 19 472133 50 92 78 19 33 21 47 50 92 78

9. Quicksort – demo 2 0 1 2 3 4 5 6 19 33 21 47 50 92 78 19 21 33 47 50 92 78 19 21 33 47 50 92 78 19 21 33 47 509278 19 21 33 47 50 7892 19 21 33 47 507892 19 21 33 47 50 7892

10. Binsort • 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] ;

11. 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; } } }

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

13. i=4 6 1 2 30 5 4 7 i=4 01 2 3 6 5 4 7 i=6 0 1 2 3 6 5 47 i=6 01 2 3 4 5 67 Binsort – demo 2 0 1 2 3 4 5 6 7

14. Radixsort • 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;

15. Radixsort – cod 1 void RadixsortRecursiv(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++; RadixsortRecursiv(s,j-1,b-1,tab,n); RadixsortRecursiv(j,d,b-1,tab,n); } }

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

17. 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; }

18. 78 2 4 1 0 9 7 3 0111 1000 0010 0100 0001 0000 1001 0111 0011 7 3 2 4 1 0 978 0111 0011 0010 0100 0001 0000 10010111 1000 7 3 2 4 1 0 7 9 8 0111 0011 0010 0100 0001 0000 0111 1001 1000 Radixsort – demo 1 7 8 2 4 1 0 9 7 3 0111 1000 0010 0100 0001 0000 1001 0111 0011

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

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

21. 01 2 3 4 7 7 9 8 0 1 23 4 7 7 9 8 0 1 2 3 4 7 7 9 8 0 1 2 3 4 7 7 9 8 00000001 0010 0011 0100 0111 0111 1001 1000 0000 0001 00100011 0100 0111 0111 1001 1000 0000 0001 0010 0011 0100 0111 0111 1001 1000 0000 0001 0010 0011 0100 0111 0111 1001 1000 Radixsort – demo 4

22. 0 1 2 3 4 7 7 98 0 1 2 3 4 7 7 89 0000 0001 0010 0011 0100 0111 0111 1001 1000 0000 0001 0010 0011 0100 0111 0111 1000 1001 Radixsort – demo 5