Tablouri Unidimensionale

Sortare
Autori:-Balan Rares Ciprian
-Antal Stefan
 Cuprins

1.Definiție
2.Clasificare
3.Metode:
-Metoda Bulelor
-Selecție
-Inserție
-STL Sort
4.Suplimentar
1.Definiție:
-Sortarea unui tablou reprezintă o
rearanjare a elementelor astfel încât
valorile acestora să fie într-o anumită
ordine. De regulă ordinea cerută este
cea crescătoare sau descrescătoare.
2.Clasificare: a)Neeficienți: -Metoda Bulelor
-Interschimbare
b)Eficienți: -Quick Sort
-Merge Sort (Vezi pnct. 4)
-Heap Sort
 3.Metode

 Metoda Bulelor (Neeficienta) :Cunoscuta si sub numele BubbleSort, metoda

bulelor se bazeaza pe urmatoarea idee:


•fie un vector X[] cu n elemente
•parcurgem vectorul și pentru oricare două elemente învecinate care nu
sunt în ordinea dorită, le interschimbăm valorile
•după o singură parcurgere, vectorul nu se va sorta, dar putem repeta
parcurgerea
•dacă la o parcurgere nu se face nicio interschimbare, vectorul este sortat
Exemplu

0 1 2 3 4
47 23 12 17 30
Deoarece am făcut interschimbări, nu
știm dacă vectorul este ordonat.
0 1 2 3 4
47 23 12 17 30
47 <- -> 23 12 17 30
23 47 12 17 30
23 12 47 17 30
23 12 17 47 30
23 12 17 30 47
23 12 17 30 47
 Algoritmul: int n, v[100];

 ///citire v[] cu n elemente

 bool sortat; do
 {
 sortat=true;
 for(int i = 0 ; i < n – 1 ; i++)
 {
 int aux = v[i];
 v[i] = v[i+1];
 v[i+1] = aux;
 sortat = false;
 }
 }
 while(!sortat);
 Observatie:La fiecare parcurgere cel puțin un element ajunge pe poziția sa
finală:
 la prima parcurgere cel mai mare element al vectorului ajunge pe poziția sa
finală;
 la a doua parcurgere următorul cel mai mare element ajunge pe poziția
finală;
 Observăm că nu mai are rost să parcurgem aceste elemente, fixate. Astfel,
putem parcurge vectorul numai până la indicele unde s-a făcut ultima
interschimbare la parcurgerea anterioară.
 Algoritm: int n, v[100];
 //citire v[] cu n elemente if(v[i] > v[i+1])
 bool sortat; {
 int m = n; int aux = v[i];
 Do v[i] = v[i+1];
 { v[i+1] = aux;
 sortat = true; sortat = false;
 int p = m; m = i + 1;
 for(int i = 0 ; i < p - 1 ; i ++) }
 }
 while(!sortat);
 Sortare prin selectie:
 (Selection Sort) se bazeaza pe urmatoarea idee:
 - fie un vector X[] cu n elemente;
 - plasăm în X[0] cea mai mică valoare din
vector;
 - plasăm în X[1] cea mai mică valoare rămasă;
 etc.
 Algoritmul: int n, X[100];
 //citire X[] cu n elemente
 for(int i = 0 ; i < n - 1 ; i ++)
 for(int j = i + 1 ; j < n ; j ++)
 if(X[i] > X[j])
 {
 int aux = X[i];
 X[i] = X[j];
 X[j] = aux;
 }
 Observatie : Algoritmul descris mai sus se mai numește sortare prin
selecție generală, sau implicită. O altă variantă este următoarea, în care
pentru fiecare secvență i ... n-1 se determină explicit minimul și se
interschimbă cu X[i].
 Algoritmul: int n, X[100];
 //citire X[] cu n elemente
 for(int i = 0 ; i < n - 1 ; i ++)
 {
 int p = i;
 for(int j = i + 1 ; j < n ; j ++)
 if(X[j] < X[p])
 p= j;
 int aux = X[i];
 X[i] = X[p];
 X[p] = aux;
 }
 Sortarea prin inserție (Insertion Sort) se bazează pe următoarea idee:

 fie un vector X[] cu n elemente;

 dacă secvența cu indici 0, 1, …, i-1 este ordonată, atunci putem
insera elementul X[i] în această secvență astfel încât să fie ordonată
secvența cu indici 0, 1, …, i-1, i.
 luăm pe rând fiecare element X[i] și îl inserăm în secvența din stânga
sa
 la final întreg vectorul va fi ordonat
 Algoritmul : int n, X[100];
 //citire X[] cu n elemente
 for(int i = 1 ; i < n ; i ++)
 {
 int x = a[i];
 int p = i - 1;
 while(p >= 0 && a[p] > x)
 a[p + 1] = a[p], p --;
 a[p + 1] = x;
 }
 Sau

 for(int i = 1 ; i < n ; i ++)

 {
 int p = i;
 while(p > 0 && a[p] < a[p-1])
 {
 int aux = a[p];
 a[p] = a[p-1];
 a[p-1] = aux;
 p --;
 }
 }
 STL (Standard Template Library) conține o funcție ce realizează
sortarea eficientă a unui tablou, sort. Ea poate fi folosită atât pentru
sortarea unui vector STL, cât și pentru sortarea unui tablou standard
C. Elementele tabloului pot avea orice tip pe care este definită
operația <.

 Funcția sort este declarată în header-ul algorithm, care trebuie inclus

în programul sursă:
 #include <algorithm>
 Ordonare
: crescatoare: Funcția sort permite sortarea unei secvențe a tabloului.
Pentru a sorta în tabloul A secvența delimitată de indicii s și d (inclusiv
aceștia), se face apelul:

sort(A + s, A + d + 1);
Daca se doreste sortarea unui tablou A cu n elemente, indexate de la 0 la n-1
apelul va fi:
sort(A, A + n)
Daca tabloul este indexat de la 1 la n apelul va fi:
Sort(A +1, A + n + 1)
Apelurile de mai sus sorteaza crescator elemente ale secventei/tabloului
 Ordonarea descrescatoare: Pentru a sorta descrescător elementele
secvenței delimitate de indicii s și d în tabloul A cu elemente de tip
int, se transmite funcției sort un parametru suplimentar, astfel:

 sort(A + s, A + d + 1, greater<int>());
 Dacă elementele tabloului A sunt de tip double, apelul va fi:

 sort(A + s, A + d + 1, greater<double>());
 Ordonarea dupa alte criterii: Al treilea parametru al funcției sort este
de fapt o funcție de comparare, care se folosește pentru a stabili
dacă elementele secvenței/tabloului sunt în ordinea dorită. Mai
precis, această funcție are doi parametri de același tip cu elementele
tabloului sortat și returnează true dacă primul parametru este situat
înaintea celui de-al doilea în ordinea în care se doresc a fi ordonate
elementele tabloului și false în caz contrar.

 Astfel sortarea descrescătoare poate fi realizată și astfel:

 Algoritm :
 bool fcmp(int x, int y)
 {
 if(x > y)
 return true;
 return false;
 }
 ...
 int A[1001], n;
 ...
 sort(A + 1, A + n + 1, fcmp);