Sunteți pe pagina 1din 6

Metode de sortare

1. MergeSort (sortare prin interclasare)

Varianta interativa

void interclasare(int a[], int n, int b[], int m, int c[], int &k)
{
int i=0, j = 0;
while(i<n && j<m)///atata timp cat mai avem valori in ambele tablouri
if(a[i] == b[j])
c[k++] = a[i], i++, j++;
else
if(a[i] < b[j])
c[k] = a[i], k++, i++;
else
if(a[i] > b[j])
c[k] = b[j], k++, j++;
while(i<n)
c[k] = a[i], k++, i++;

while(j < m)
c[k] = b[j], k++, j++;
}

Varianta recursiva
Se da un vector cu n numere naturale. Ne propunem sa sortam acest vector cu
metoda divide et impara, impartind tabloul in jumatati, pana ajungem la
probleme elementare (prelucrarea a 2 valori).

#include <iostream>
using namespace std;

int a[45], n;
void citire(int i)
{
if(i == n) return;
cin>>a[i];
citire(i+1);
}
void afisare(int i)
{
if(i == n) return;
cout<<a[i]<<' ';
afisare(i+1);
}

///varianta recursiva prin metoda dei


void interclasare(int s, int d, int mj)
{
///i va parcurge vectorul de la s la mj, iar j va parcurge vectorul de la mj+1, la d
int i=s, j = mj+1, b[45], k = 0;
while(i<=mj && j<=d)
if(a[i] < a[j])
b[k] = a[i], k++, i++;
else
b[k++] = a[j++];
while(i<=mj)
b[k++] = a[i++];
while(j<=d)
b[k++] = a[j++];
///cu i parcurg vectorul a de la pozitia s la pozitia d
///cu j parcurg vectorul b, care are k elemente, de la pozitia 0 la pozitia k-1

for(i=s, j = 0; j<k;i++, j++)


a[i] = b[j];
}

void divide(int s, int d)


{
if(s < d)
{
int mj = (s + d)/ 2;
divide(s, mj);
divide(mj + 1, d);
interclasare(s, d, mj);
}
}

int main()
{
cin>>n;
citire(0);
divide(0, n-1);
afisare(0);
return 0;
}
In functia divide am impartit tabloul dat a in 2 subvectori. Fiecare dintre
acesti subvectori a fost reimpartit, iar la final am ajuns sa avem cate 2
elemente de comparat. In fuctia interclasare, am comparat 2 subvectori si
sirul ordonat l-am salvat intr-un vector auxiliar – b, cu metoda clasica de
interclasare. Dupa interclasarea celor 2 subvectori, am copiat vectorul
rezultat in vectorul initial de la pozitia s la pozitia d.
Primul subvector era cuprins intre indicia i si mj, iar al doilea subvector intre
indicia mj+1 si d.

Tema:
1. n = 6, a = (9, 1, 8, 5, 3, 7)
Sa se scrie toate iteratiile (pe caiet) care se executa pentru sortarea vectorului
prin metoda MergeSort cu dei.

Problema - vector:
Se da vectorul a cu n numere nat. Sa se fermeze un al doilea vector cu valorile
care sunt termini ai sirului lui Fibonacci. Sortati noul vector prin metoda
interclasarii.

/**Se da vectorul a cu n numere nat, 1<=n<=100.


Sa se fermeze un al doilea vector cu valorile care sunt termini ai sirului lui
Fibonacci.
Sortati descrescator noul vector prin metoda interclasarii.Afisati noul vector
dupa sortare
1, 0|||| 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...**/
#include <iostream>
using namespace std;

int n, a[100], m, b[100];


void citire(int i)
{
if(i == n)
return;
cin>>a[i];
citire(i+1);
}

void afisare(int a[], int n, int i)


{
if(i == n)
return;
cout<<a[i]<<' ';
afisare(a, n, i+1);
}

int fibo(int a, int b, int c, int x)


{
if(x < c)
return 0;
if (x == c)
return 1;
c = a + b, a = b, b = c;
return fibo(a, b, c, x);
}

///duc din a in b elem care sunt termeni in sirul lui Fibo


void formare(int i)
{
if(i == n) return;
if(fibo(1, 0, 1, a[i]) == 1)
b[m++] = a[i];
formare(i+1);
}

void interclasare(int a[], int n, int s, int d, int mj)


{
int i = s, j = mj+1, b[100], k = 0;
while(i<=mj and j <=d)
if(a[i] > a[j])
b[k++] = a[i++];
else
b[k++] = a[j++];

while(i<=mj)
b[k++] = a[i++];
while(j<=d)
b[k++] = a[j++];

for(int i=s, j =0;j<k;i++, j++)


a[i] = b[j];
}
void divide(int a[], int n, int s, int d)
{
if(s < d)
{
int mj = (s + d)/2;
divide(a, n, s, mj);
divide(a, n, mj+1, d);
interclasare(a, n, s, d, mj);
}
}

int main()
{
cin>>n;
citire(0);
formare(0);
divide(b, m, 0, m-1);
afisare(b, m, 0);

return 0;
}

Tema
2.Se da un vector cu n valori nr nat, 1<=n<=34. Formati in alt vector cu
valorile care au ambii vecini termini in sirul lui Fibonacci. Sortati crescator
noul vector.

Problema - matrice
Se da o matrice an*m. Sortati descrescator linia k prin metoda MergeSort.
#include <iostream>
using namespace std;

int n, m, a[100][100], k;

void interclasare(int s, int d, int mj)


{
int i=s, j = mj+1, b[100], nrelem = 0;
while(i<=mj and j <=d)
if(a[k][i] > a[k][j])
b[nrelem++] = a[k][i++];
else
b[nrelem++] = a[k][j++];

while(i<=mj)
b[nrelem++] = a[k][i++];

while(j<=d)
b[nrelem++] = a[k][j++];
}

void dei(int s, int d)


{
if(s<d)
{
int mj = (s + d)/2;
dei(s, mj);
dei(mj+1, d);
interclasare(s, d, mj);
}
}
int main()
{
cin>>n>>m>>k;
for(int i=0; i<n; i++)
for(int j=0; j<m; j++)
cin>>a[i][j];

dei(0, m-1);
cout<<endl<<endl;
for(int i=0; i<n; i++)
{
for(int j=0; j<m; j++)
cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;
}