ATP – Seminar 6

Sortari
Cuprins
1. Metoda sortării rapide (QuickSort)
2. Metoda sortării cu micșorarea incrementului (Metoda Shell)
3. Sortare pe baza rădăcinii (radix sort)
4. Sortare prin cupe (Bucket Sort)
5. Metoda de sortare Heap
6. Metoda de sortare prin numărare - Tema

1. Metoda sortarii rapide (QuickSort)

• strategia are la bază o tehnică de tip "divide et impera" (sunt mai ușor de sortat două tabele mici, decât o tabelă
mare)
• foloseste partiţionarea ca idee de bază
• caracteristici:
– eficient pentru fișiere sau tabele mari,
– ineficient pentru cele de mici dimensiuni.
– ușor de implementat,
– consumă mai puţine resurse decât orice altă metodă de sortare.
– algoritm dependent de ordinea datelor de intrare
Descriere metoda:
• Având o tabelă A cu N elemente, alegem o cheie pivot v în jurul căreia rearanjăm elementele.
• Pivotul poate fi ales în mai multe moduri. O modalitate simplă ar fi să alegem ca pivot primul element.
• După ce avem pivotul, partiţionăm tabela.
• Prin partiţionare:
– toate elementele cu chei mai mici decât pivotul le vom plasa în partea stângă a tabelei,
– iar elementele cu chei mai mari decât pivotul în partiţia dreaptă.
• După aceea apelăm recursiv algoritmul de sortare rapidă relativ la cele două subtabele formate prin
partiţionare.
Se consideră următoarea schemă de comparaţie-interschimb:
• folosindu-se 2 indicatori i, j, cu valorile iniţiale i = 1 și j = N,
• se compară înregistrarea cu numărul de ordine i cu înregistrarea cu numărul de ordine j;
• algoritmul mută:
– pe i la dreapta, până când găsește o cheie mai mare decât pivotul v
– si mută pe j la stânga până când găsește o cheie mai mică decât pivotul v.
• dacă nu este necesară interschimbarea, se decrementează j cu 1 si se repetă procesul de comparaţie;
• dacă apare un interschimb, se incrementează i cu 1 si se continuă compararea, mărind i până la apariţia unui
nou interschimb;
• apoi se decrementează j, continuându-se acest proces de numit "ardere a lumânării la ambele capete", până
când i >= j.
• procedura se apelează recursiv printr-un apel de forma: SORTARE_Rapida(A, 1, N);
Exemplu:

Sortarea tabelei A folosind algoritmul de sortare QuickSort, în ordine crescătoare:

• Initial:
• Pivot = 7 (primul elemente)
• i=7 (primul)
• j=6 (ultimul)
• Tabela: 7,4,2,8,5,9,3,10,1,6

Indicatii cod:

- biblioteci else
{
int poz(float *x,int p,int u) i+=di;
{ int i,j,l,di,dj; j+=dj;
float v; }
//di, dj: pasii de incrementare pentru i si j; ei indica return i;
sensul parcurgerii }

i=p; j=u; di=0; dj=-1; void quick(float *x,int p,int u)

{ int i;
while(i<j) if (p<u)
if (x[i]>x[j]) { i=poz(x,p,u);
{ quick(x,p,i-1);
v=x[i]; quick(x,i+1,u);
x[i]=x[j]; }
x[j]=v; }

l=di; - functia main

di=-dj; { - declarare variabile: n,i - intregi; v[100] –real
dj=-l; - citire dimensune vector: n
- citire elemente vector
i+=di;
j+=dj; quick(v,0,n-1); //apel functie quick(…)
}
- afisare vector sortat
}
 2. Metoda sortarii cu micsorarea incrementului (Metoda Shell)

• metoda este o extensie simplă al metodei de sortare prin inserare

• îmbunătăţeste performanţele algoritmului prin interschimbarea elementelor cele mai îndepărtate.

• ideea de bază - rearanjarea elementelor din tabela A astfel încât, luând fiecare al h-lea element
(începând de oriunde), să obţinem o tabelă sortată => spunem că tabela este h-sortată.

 tabelă h-sortată este formată din h subtabele sortate independent.

• folosind astfel o procedură pentru fiecare secvenţă de valori ale lui h, care se termină pentru valoarea
1, va rezulta o tabelă sortată.
Sa consideram tabela A si un increment mai mare decât 1, fie acesta h (h initial este n/2 unde n este
dimensiune vector) . Vom avea atunci urmatoarele subtabele:
• Subtabelul1: A[1], A[h +1], A[2h +1], ….
• Subtabelul2: A[2], A[h +2], A[2h +2], ….
• Subtabelul3: A[3], A[h +3], A[2h +3], ….
• …………………………………………...
• Subtabelul h: A[h], A[2h], A[3h], ….
•
• Daca sortam fiecare din cele h subtabele, folosind de exemplu algoritmul de sortare prin inserare,
atunci elementele "îndepartate" se vor apropia, sarind cu pasul h catre stânga.
• În final, vom proceda la o sortare prin inserare cu incrementul 1, ceea ce va necesita un timp foarte
scurt deoarece tabela nu mai necesita corectii importante, majoritatea înregistrarilor fiind în pozitia
crescatoare dorita.

Exemplu:
Sortarea tabelei A algoritmul de sortare Shell, în ordine crescătoare.
A = 11,10,9,8,7,6,5,4,3,2,1,0; n=12

Pasul 1: Crearea celor h subtabele (Fig. - (b))

• - Să presupunem că am ales incrementul h = 5. Se creează cele 5 subtabele
• Subtabela 1: 11, 6, 1
• Subtabela 2: 10, 5, 0
• Subtabela 3: 9, 4
 • Subtabela 4: 8, 3
• Subtabela 5: 7, 2
Pasul 2: Am sortat cele 5 subtabele (Fig. - (c))
Pasul 3: Tabela iniţială după pasul de sortare cu incrementul 5 (Fig. - (d))
Pasul 3: Tabela iniţială după pasul de sortare cu incrementul 1 (Fig. - (d))

Indicatii cod:

- biblioteci

void sort_shell(float v[], int l)

{ int i,j,inc;
float a;

for(inc=l/2; inc>0; inc=inc/2)

for(i=inc; i<l; i++)
for(j=i-inc; (j>=0)&&(v[j]>v[j+inc]); j=j-inc)
{ a=v[j];
v[j]=v[j+inc];
v[j+inc]=a;
}
}
- functia main
{…}

3. Sortare pe baza rădăcinii (radix sort)

Ipoteze: chei de lungimi egale (întregi, șiruri de caractere)
• LSD (cifra cea mai puţin semnificativă),
• MSD (cifra cea mai semnificativă)
• Invers intuitivă: începe de la cifra cea mai puţin semnificativă
• Utilizata la calculatoarele mai vechi pentru sortarea cartelelor perforate

Exemplu:
n=10
A=
{
5436,
4578,
 8654,
1027,
9862,
2456,
5874,
2357,
0125,
6921
}
Indicatii cod:
Radix_Sort(a, n, d)
pentru i=1:d
aplică o metodă stabilă pentru sortare după cifra i
4. Sortare prin cupe (Bucket Sort)

Ipoteză: elemente uniform distribuite în [0,1]

• Divide [0,1] în n intervale (cupe)
• Plasează fiecare element în cupa corespunzătoare
• Sortează fiecare cupă (listă scurtă)
• Concatenează cupele în ordine

Indicatii cod:
Sortare_cupe(a, n)
pentru i=1:n
copiază a[i] în cupa corespunzatoare

sortează lista b[i] (de ex. prin inserare)

concatenează toate cupele

5. Metoda de sortare Heap

Exemplu*
- se da un număr de elemente si un tablou unidimensional:
• ex: n=5
• v = 4, 10, 3,5,1 cu i=0,4

- se construiește heap-ul (arborele binar, muntele) folosind elementele vectorului

- pe baza heap-ului creat se realizeaza Max Heap-ul pentru sortarea elementelor in ordine crescatoare
• in Max Heap parintele este mereu mai mare sau egal cu copii lui

• se verifica elementul 10 – este mai mare decat toti copii lui

• se verifica elementul 4 – 4 este mai mic decat 10 => se interschimba

 => si vectorul devine:

• se verifica 5 – 5 e mai mare decat 4 => se interschimba

=> si vectorul devine

• cum condiţia ca toţi parintii sa aiba copii mai mici este îndeplinita, atunci se interschimba primul nod
(10) cu ultimul (1) din cadrul arborelui

=> si vectorul devine

• se eliminina ultimul nod (10)

• se verifica elementul 5 – 5 e mai mare decat 1 => se interschimba

=> si vectorul devine

• se verfica elementul 1 – 1 mai mic decat 4 => se interschimba

 => si vectorul devine

• cum condiţia ca toţi parintii sa aiba copii mai mici este îndeplinita, atunci se interschimba primul nod
(5) cu ultimul (1) din cadrul arborelui

=> si vectorul devine

• se verifica elementul 4 – 4 mai mare decat 1 => se interschimba

=> si vectorul devine

• cum condiţia ca toţi parintii sa aiba copii mai mici este îndeplinita, atunci se interschimba primul nod
(4) cu ultimul din cadrul arborelui (3)

=> si vectorul devine

• arborele ramas este deja unul sortat, deci se interschimba primul element (3) cu ultimul (1)

=> si vectorul devine

• in arbore a mai ramas un singur element => conditie de oprire indeplinita

=> forma finala vector sortat

6. Metoda de sortare prin numărare - Tema