METODE DE SORTARE A SIRURILOR

I. Sortarea cu metoda bulelor

(BubbleSort)

1.Informaţii generale: 
       Metoda de sortare BubbleSort porneşte de la o proprietate evidentă
a unui şir sortat: oricare două elemente alăturate respectă relaţia de
ordine. Astfel, dacă oricare pereche de elemente alăturate respectă
relaţia de ordine, atunci, conform tranzitivităţii relaţiei, întreg şirul va fi
ordonat. Cele două elemente consecutive ale şirului de sortat vor
forma “bulele” pe care se va verifica relaţia de ordine cerută. Este cea
mai simplă metodă de sortare şi nu necesită cunoaşterea detaliată a
limbajului de programare.
 
2.Prezentarea algoritmului:
            Se parcurge vectorul de sortat şi se compară elementele
consecutive. Dacă acestea nu se află în ordinea dorită, se
interschimbă. Când se va ajunge la ultimul element al vectorului,
parcurgerea se reia şi se vor verifica din nou elementele vecine, cu
realizarea interschimbărilor acolo unde sunt necesare,  până când, la o
ultimă parcurgere nu mai este necesară nici o interschimbare, prin
urmare, vectorul este ordonat.
            Se va folosi o variabilă de tip logic, care va marca dacă la o
parcurgere se fac interschimbări (se iniţializează la începutul
parcurgerii, iar dacă se face măcar o interschimbare, i se va schimba
valoarea). Algoritmul se opreşte atunci când această variabilă îşi
păstrează valoarea primită la începutul parcurgerii (nu au mai fost
necesare interschimbări).
 
Exemplu :  şirul iniţial este {5, 8, 4, 7, 6}
i x[1] x[2] x[3] x[4] x[5]
x[1],x[2] 5 8 4 7 6
Compar 5 cu 8: ordinea e cea dorită
x[2],x[3] 5 8 4 7 6
Compar 8 cu 4: ordinea nu e cea dorită ;
 se interschimbă
x[3],x[4] 5 4 8 7 6
Compar 8 cu 7: ordinea nu e cea dorită ;
se interschimbă
x[4],x[5] 5 4 7 8 6
Compar 8 cu 6: ordinea nu e cea dorită ;
se interschimbă ; se reia parcurgerea
x[1],x[2] 5 4 7 6 8
Compar 5 cu 4: ordinea nu e cea dorită ;
se interschimbă ;
x[2],x[3] 4 5 7 6 8
x[3],x[4] 4 5 7 6 8
x[4],x[5] 4 5 6 7 8
La următoarea parcurgere, nu se mai
realizează interschimbări

Vizualizare animatie algoritm     

3. Varianta pseudocod a    algoritmului:

 repetă
ok←fals;
pentru i←1, n-1 execută
                dacă x[i]>x[i+1] atunci
                          x[i]↔x[i+1];
                         ok←adevarat;
                sfârşit dacă;
sfârşit pentru;
până când ok=fals;
 
5. Implementare Pascal:
repeat
ok:=true;
for i:=1 to n do
if x[i]>x[i+1] then
          begin
          aux:=x[i];
          x[i]:=x[i+1];
          x[i+1]:=aux;
          ok:=false;
          end;
 until ok;

II. Sortarea prin selecţie

(SelectSort)
1.Informaţii generale
         Ideea care stă la baza sortării prin selecţie este de a alege din şirul
de sortat acel element care va fi aşezat pe prima poziţie a vectorului
(cel mai mic). Presupunând ca acest element se află iniţial în vectorul
de sortat pe poziţia k, va fi necesară o interschimbare între el şi
elementul de pe prima poziţie a vectorului. Se va aplica această regulă
pentru restul elementelor vectorului, începând cu al doilea, până vom
obţine şirul sortat.
2.Prezentarea algoritmului: 
Se observă că se parcurge şirul iniţial pentru a amplasa pe poziţia
curentă elementul corespunzător din şirul ordonat. Pentru a identifica
acest element, va trebui să căutăm cel mai mic element al subşirului
format din elementele rămase, deci vom realiza o parcurgere a acestui
subşir. După identificarea elementului care trebuie plasat, se
realizează interschimbarea. Se va folosi o variabilă auxiliară,min, care
va ajuta la interschimbare.
Exemplu:Fie tabloul X=(5,0,8,7,3)

3. Varianta pseudocod a algoritmului:

pentru i←1,n execută
          min←xi; ind←i ;
         pentru j←i+1, n execută
                   dacă min>xj atunci          
                            min←xj ;              
                            ind←j ;
                   sfârşit dacă;
         xind←xi ;                                  
         xi←min ;                                 
         sfârşit pentru;
sfârşit pentru;
4.Implementare Pascal :
for i :=1 to n-1 do
         begin
         ind:=i;
         for j :=i+1 to n do
                   if x[ind] >x[j] then ind :=j ;
         aux:= x[ind];
         x[ind]:=x[i];
         x[i]:=aux;
         end;