Tablouri unidimensionale (vectori)

1.1. Noţiuni teoretice

Declararea vectorului:
tip_elemente_vector nume_vector [dimensiune_maximă_vector]; unde:
1
• tip_elemente_vector - precizează tipul elementelor vectorului (întregi, reale, caracter, etc.)
• nume_vector – identificator, precizează numele dat tabloului
• dimensiune_maximă_vector – numărul maxim de elemente din vector (o constantă întreagă)
! Dacă vectorul conține n elemente, indicii (pozițiile) elementelor au valori întregi în intervalul
[0,n-1].
Exemple:

• int vect [25] – am declarat un tablou unidimensional (vector) cu numele vect, de maxim 25 elemente
de tip întreg. Elementele vectorului au indicii în intervalul [0,24].
• float x [55] – am declarat un tablou unidimensional (vector) cu numele x, de maxim 55 elemente
de tip float. Elementele vectorului au indicii în intervalul [0,54].
!Alte modalități de declarare a vectorilor:
a) # define maxim 10 //am definit constanta maxim cu valoarea 10
char vect[maxim]; //am declarat un tablou unidimensional (vector) cu numele vect, de maxim 10
elemente de tip caracter. Elementele vectorului au indicii în intervalul [0,9].
b) tip_elemente_vector nume_vector [dimensiune_maximă_vector]= lista de valori;
Exemple:
➢ int vect[6]={21,22,23,24,25,26}
➢ float x[5]={2.3, 7.5, 2.15, 4.39, 9.1}
!Atunci când declarăm un vector cu inițializarea elementelor sale, numărul maxim de elemente ale
tabloului nu trebuie precizat neapărat deoarece compilatorul determină automat mărimea tabloului în
funcție de numărul de elemente inițializate.
Exemple:
➢ char vect[]={‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’}
➢ float x[]={2.3, 7.5, 2.15, 4.39, 9.1}
Un element al unui vector poate fi utilizat ca orice altă variabilă. Pentru a ne referi la un
element al vectorului folosim numele vectorului și indicele elementului între paranteze pătrate.
Exemplu:
➢ int vect[6]={21,22,23,24,25,26}
vect = 21 22 23 24 25 26
indice (i) 0 1 2 3 4 5
cum ne referim la element vect[0] vect[1] vect[2] vect[3] vect[4] vect[5]

Elementul aflat pe poziția 3 în vectorul vect are valoarea 23 (vect[2]=23).

!Pentru simplitate, se pot considera elementele vectorului începând cu poziția 1, caz în care trebuie
să avem grijă când inițializăm dimensiunea maximă a vectorului, iar pentru elementul aflat pe poziția 0 are
valoarea alocată implicit la compilare și rămâne neutilizat.
Inițializarea unui vector:
int x[10],n;
a. prin introducerea datelor de la cin>>n;
tastatură/fișier for (int i=0; i<n; i++)
cin >> x[i];
//elementele vectorului x vor fi introduce de la tastatură
b. prin folosirea instrucţiunii de int a[10],n;
atribuire for (int i=0; i<n; i++)
a[i]=2*i;

c. prin utilizarea unei constante
de tip tablou
Afișarea elementelor unui vector:
for (int i=0; i<n; i++)
cout<<vect[i];
//toate componentele vectorului a sunt iniţializate cu 2*i (deci
elementele vectorului vor fi 0, 2,4,6,8...
int v[5] = {10,20,30,40,50};
int t[10] = {11,12,13};
// t[0] = 11, t[1] = 12, t[2] = 13; celelalte componente ale tabloului
t[3], …, t[9] au valoarea 0 dacă tabloul este declarat global (înainte
de funcția main) sau o valoare iniţială imprevizibilă dacă tabloul
este declarat local (în interiorul funcției main). 2

Tablouri unidimensionale (vectori)

Inserări și eliminări de componente dintr-un vector
1. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100). Să se scrie
un program care elimină din vector cel mai mare element par.
Cum procedăm?
• Citim elementele vectorului și pe măsură ce le citim determinăm și cel mai mare element par
(reținem cel mai mare element par și poziția pe care acesta se află în variabila poz)
• Elementele cu indicii poz+1, poz+2,...,nse mută spre stânga cu o poziție
• Dimensiunea n a vectorului se micșorează cu 1
• Se afișează vectorul astfel obținut
Exemplu: pentru n=5 și vectorul v=(122, 13, 25, 910, 456) se va afișa: 122, 13, 25, 456 (elementul
maxim par este 910)
Elemente vector 122 13 25 910 456

Indice 1 2 3 4 5
Dorim să eliminăm din vector elementul maxim par=910 și se află pe poziția 4 (poz=4)

Elemente vector 122 13 25 910 456

Indice 1 2 3 4 5

Vectorul obținut va fi:

Elemente vector 122 13 25 456

Indice 1 2 3 4

Algoritmul:
#include <iostream>
using namespace std;
int n,i,v[101],maximp=0,poz;
int main()
{cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
{cin>>v[i];
if(v[i]%2==0 && v[i]>maximp) {maximp=v[i];
poz=i;} }
for(i=poz+1;i<=n;i++)
v[i-1]=v[i];
n--;
for(i=1;i<=n;i++) cout<<v[i]<<" "; return 0;}
 2. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100) și un număr
natural p. Să se scrie un program care elimină din vector elementele care sunt prime cu p.
Cum procedăm?
• Citim elementele vectorului și variabila p
• Parcurgem vectorul și analizăm dacă elementul de pe poziția curentă este prim cu p
• Dacă elementul de pe poziția curentă este prim cu p ștergem acest element folosind algoritmul de
la problema 1.
3
Observație:
Trebuie să fim atenți la indici pentru că în momentul în care în vector avem elemente aflate pe poziții
consecutive care îndeplinesc condiția este posibil să nu-l analizăm pe cel de-al doilea (deci valoarea
indicelui i crește doar dacă nu eliminăm element din vector)
Exemplu: pentru n=6, p=20 și vectorul v=(122, 13, 273, 910, 456, 121, 60) se va afișa: 122, 910,
456,60

Elemente vector 122 13 273 910 456 121 60

Indice 1 2 3 4 5 6 7
p 20 20
Nu sunt Sunt prime
prime între între ele și
ele și se se elimină
trece la elementul
următorul
element
Se obține vectorul și trebuie analizat dacă elementul care acum este pe poziția 2 este prim cu p:

Elemente vector 122 273 910 456 121 60

Indice 1 2 3 4 5 6
p 20 20
Nu sunt Sunt
prime între prime
ele și se între ele și
trece la se elimină
următorul elementul
element
Se obține vectorul și trebuie analizat dacă elementul care acum este pe poziția 2 este prim cu p:

Elemente vector 122 910 456 121 60

Indice 1 2 3 4 5
p 20 20 20 20
Nu sunt Nu sunt Nu sunt Sunt
prime între prime prime prime
ele și se între ele și între ele și între ele și
trece la se trece la se trece la se elimină
următorul următorul următorul elementul
element element element

Se obține vectorul și trebuie analizat dacă elementul care acum este pe poziția 4 este prim cu p:
 Elemente vector 122 910 456 60

Indice 1 2 3 4

p 20 20 20 20
Nu sunt prime Nu sunt prime Nu sunt prime Nu sunt prime
între ele și se între ele și se între ele și se între ele și se
trece la trece la trece la trece la 4
următorul următorul următorul următorul
element element element element

Algoritmul:
#include <iostream>
using namespace std;
int n,i,v[101],x,y,p,j,poz;
int main()
{cout<<"Dimensiunea vectorului:";
cin>>n;
cout<<"Numarul p:";
cin>>p;
for(i=1;i<=n;i++)
cin>>v[i];
i=1;
while(i<=n)
{x=v[i];
y=p;
while (x!=y)
if (x>y) x=x-y;
else y=y-x;
if (x!=1) i++;
else {poz=i;
for(j=poz+1;j<=n;j++)
v[j-1]=v[j];
n--;}}
for(i=1;i<=n;i++) cout<<v[i]<<" ";
return 0;}

3. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100) și un număr

natural p. Să se scrie un program care inserează între două elemente pare aflate pe poziții consecutive din
vector valoarea p.
Exemplu: pentru n=5, p=20 și vectorul v=(122, 12, 273, 910, 456) se va afișa: 122, 20, 12, 273, 910,
20, 456
Asemănător cu algoritmul de ștergere a unui element dintr-un vector, și cel de inserare presupune
modificarea elementelor din dreapta elementului după care dorim să inserăm. De data aceasta elementele vor
fi mutate spre dreapta, începând cu ultimul. Elementul de pe poziția pe care dorim să inserăm se înlocuiește
cu noua valoare, iar dimensiunea logică a vectorului crește, fără a depăși însă dimensiunea fizică.

Elemente vector 122 12 273 910 456

 Indice 1 2 3 4 5
Elementele sunt pare și
pe poziții consecutive în
vector
Mutăm toate elementele începând cu 12 (element aflat pe poziția 2) cu o poziție la dreapta, deci
dimensiunea vectorului crește cu 1, apoi pe poziția 2 inserăm valoarea 20.

Elemente vector 122 20 12 273 910 456

5
Indice 1 2 3 4 5 6

Următoarele elemente pare aflate pe poziții consecutive sunt 910 și 456.

Elemente vector 122 20 12 273 910 456

Indice 1 2 3 4 5 6

Elementele sunt pare

și pe poziții
consecutive în vector

Mutăm toate elementele începând cu 456 (element aflat pe poziția 6) cu o poziție la dreapta, deci
dimensiunea vectorului crește cu 1, apoi pe poziția 6 inserăm valoarea 20.

Elemente vector 122 20 12 273 910 20 456

Indice 1 2 3 4 5 6 7

#include <iostream>
using namespace std;
int n,i,v[101],p,j;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
cout<<"Numarul p:";
cin>>p;
for(i=1;i<=n;i++)
cin>>v[i];
i=1;
while(i<n)
{if (v[i]%2!=0 || v[i+1]%2!=0) i++;
else {
for(j=n;j>=i+1;j--)
v[j+1]=v[j];
v[i+1]=p;
n++;
i=i+2;}}
for(i=1;i<=n;i++) cout<<v[i]<<" ";
return 0;}
• Căutarea unei valori într-un vector – presupune căutarea unei valori între elementele unui vector.
Aceasta se poate realiza în două moduri:
➢ Căutarea secvențială – care presupune să parcurgem vectorul de la un capăt la celălalt și
să comparăm valoarea căutată cu fiecare element din vector. Pentru aceasta vom folosi o variabilă gasit
de tip adevărat sau fals. Presupunem inițial că valoarea căutată nu este în vector (deci gasit=0).
 Parcurgem vectorul, iar dacă valoarea căutată este egală cu un element din vector atunci variabila
gasit=1 și putem opri căutarea. Dacă nu oprim căutarea atunci pentru un vector cu n elemente se fac n
comparări.
Algoritmul:
#include <iostream>
using namespace std;
int v[100],n,i,gasit,x; 6
int main()
{ cin>>n>>x;
for(i=1;i<=n;i++)
cin>>v[i];
for(i=1;i<=n && gasit==0;i++)
if(v[i]==x) gasit=1;
if(gasit==1)
cout << "Numarul se afla in vector";
else cout << "Numarul nu se afla in vector";
return 0;}

➢ Căutarea binară – se poate face numai într-un vector ordonat și presupune să comparăm
elementul de căutat cu elementul de pe poziția din mijloc a vectorului. Dacă elementul căutat este
egal cu elementul din mijloc căutarea s-a terminat, altfel dacă numărul căutat este mai mic decât
elementul din mijloc începem căutarea între componentele vectorului din stânga, iar dacă numărul
căutat este mai mare decât numărul din mijloc începem căutarea între componentele vectorului din
dreapta. Procedeul de împărțire a vectorului în subvectori până când nu mai avem elemente.

Exemplu:
Se consideră următorul vector ordonat crescător de dimensiune 10:
v= 12 14 16 27 45 56 78 89 102 234

i 1 2 3 4 5 6 7 8 9 10

în care dorim să căutăm x=27

Notăm cu st primul indice al vectorului şi cu dr ultimul indice al vectorului, iar mij este indicele
elementului din mijloc al vectorului mij=(st+dr)/2.
st dr mij Explicație

v= 12 14 16 27 45 56 78 89 102 234

i 1 2 3 4 5 6 7 8 9 10
1 10 (1+10)/2=5
x=27 < v[5]=45, deci vom continua căutarea în subvectorul din stânga,
adică dr=mij-1

v= 12 14 16 27 45 56 78 89 102 234

i 1 2 3 4 5 6 7 8 9 10
1 5 (1+5)/2=3

x=27 > v[3]=16, deci vom continua căutarea în subvectorul din dreapta,
adică st=mij+1

4 5 (4+5)/2=4 v= 12 14 16 27 45 56 78 89 102 234

 i 1 2 3 4 5 6 7 8 9 10

x=27 = v[4]=27, deci am terminat căutarea

Algoritmul:
#include<iostream>
using namespace std; 7
int i,n,x,st,dr,mij,gasit,v[50];
int main()
{cin>>n>>x;
for(i=1;i<=n;i++) cin>>v[i];
st=1;
dr=n;
gasit=0;
while (st<=dr && gasit!=1)
{ mij=(st+dr)/2;
if (v[mij]==x) gasit=1;
else if (x<v[mij]) dr=mij-1;
else st=mij+1;}
if (gasit==1) cout<<"Numarul se afla in vector"<<endl;
else cout<<"Numarul nu se afla in vector"<<endl;
return 0;}
Vector de frecvență. Vector caracteristic

Vectorul de frecvenţe reţine numărul de apariţii al fiecărei valori citite într-un vector.
Folosirea vectorului de frecvenţe permite scrierea unor algoritmi eficienţi în cazul în care datele de
intrare au valori dintr-un domeniu cunoscut care poate fi prelucrat rapid.
Folosirea unui vector de frecvență sau marcare este eficientă numai în cazul în care valorile care
interesează sunt întregi și numărul valorilor distincte posibile este cel mult 1.000.000 pentru un timp maxim
de 1 sec/test.
De exemplu acest vector poate fi folosit pentru sortarea rapidă a datelor, în timp liniar.
Tot cu ajutorul acestui vector pot fi implementate operaţiile de bază cu mulţimi:
- Căutarea unui element
- Intersecţia a două (sau mai multe) mulţimi
- Reuniunea a două (sau mai multe) mulţimi

Într-un vector caracteristic, pe poziția i este stocată o informație despre numărul i. De cele mai
multe ori, pe poziția i se va găsi o valoare booleană (true sau false) care indică, spre exemplu, dacă i se
află într-o listă dată de întregi sau nu.
 Vector caracteristic
- are doar valori de 0 și 1
- pe poziția i are valoarea 0 dacă i nu se
regăsește în listă sau valoarea 1 dacă i
se regăsește în listă.

Vector de frecvență
- pe poziția i rețin numărul de
apariții ale lui i (frecvența lui )

Exemplu:
Se dau două șiruri de cifre zecimale. Să se determine cifrele comune, în ordine crescătoare.
În funcție de numărul de cifre din cele două șiruri, putem realiza diverse soluții:
❑ căutăm fiecare termen din primul șir în al doilea șir. Șirul cu valorile comune va trebui sortat.
❑ dacă șirurile sunt sortate (sau le sortăm) procedăm ca mai sus, dar căutăm binar. Șirul cu valorile
comune este de la început sortat.
❑ dacă șirurile sunt sortate (sau le sortăm) putem folosi interclasarea pentru a afla elementele
comune.

Nicio soluție dintre cele de mai sus nu ține cont de o proprietate a valorilor din șir – că sunt cifre,
adică între 0 și 9. Putem proceda astfel:
❑ pentru fiecare șir vom folosi un vector cu doar 10 elemente, indexate de la 0 la 9; fie acestea
v[10] și u[10];
❑ indicii elementelor din șir reprezintă cifrele – valorile posibile ale elementelor din șir;
❑ inițial elementele celor doi vectori sunt 0;
❑ pentru fiecare valoare x (care este cifră) care apare în primul șir vom marca în vectorul v
elementul corespunzător cu 1, v[x] = 1;
❑ similar, fiecare element y din al doilea șir va fi marcat în vectorul u cu 1, u[y] = 1;
❑ la final sunt comune cifrele c (de la 0 la 9) care sunt marcate cu 1 atât în vectorul v, cât și în
vectorul u.
Cei doi vectori v și u sunt vectori caracteristici. Elementele lor caracterizează cifrele dintre 0 și 9,
stabilind despre fiecare cifră dacă face sau nu parte din șirul corespunzător.
Observăm că nu trebuie memorate elementele celor două șiruri date. Ne interesează numai
valorile distincte care apar în fiecare șir, indiferent de ordinea în care apar.

Observații:
❑ vectorul caracteristic are dimensiune constantă – egală cu numărul de valori pe care le
caracterizează;
❑ elementele vectorului caracteristic sunt 0 sau 1 (echivalent cu Adevărat și Fals); valorile din
vectorul caracteristic NU sunt valorile date;
❑ valorile date se află printre indicii vectorului caracteristic, respectiv indicii corespunzători
elementelor egale cu 1;

Când folosim vectorul caracteristic?

 Pentru a putea folosi un vector caracteristic trebui îndeplinite (cel puțin) următoarele condiții:
❑ ordinea datelor de intrare nu contează
❑ datele de intrare au valori mici, sunt numere naturale dintr-un interval de forma [0,M] sau pot fi
echivalente cu astfel de numere
❑ practic, putem folosi un vector caracteristic dacă memoria disponibilă permite declararea unui
vector cu un număr de elemente corespunzător:
❑ dacă datele de intrare sunt din intervalul [0, 1000] sau [0,10000] putem folosi un vector 9
caracteristic
❑ dacă datele de intrare sunt din intervalul [0, 1 milion] putem folosi un vector caracteristic – deși
poate există metodă mai bună
❑ dacă datele de intrare sunt din intervalul [0, 1 miliard] NU putem folosi un vector caracteristic

Exemplu:
Să considerăm un șir de cifre zecimale. Să se determine cifra care apare de cele mai multe ori. Dacă
sunt mai multe cifre care apar de număr maxim de ori, să se determine cea mai mică.
De această dată nu putem folosi un vector caracteristic, dar putem folosi un vector de frecvență, adică
un vector cu același număr de elemente ca numărul posibil de valori distincte din șirul dat (adică 10), cu
semnificația: v[c] = numărul de apariții ale cifrei c în șirul dat.
După construirea acestui vector, valoarea maximă din el va reprezenta numărul maxim de apariții ale
unei cifre, iar indicii pentru care elementul corespunzător are valoare maximă reprezintă cifrele care apar
de număr maxim de ori.
Interclasarea a doi vectori
Considerăm două tablouri unidimensionale cu elemente numere întregi ordonate crescător. Se dorește
construirea unui alt tablou, care să conțină valorile din cele două tablouri, în ordine.
Fie două tablouri, x cu n, respectiv y cu m elemente, ordonate crescător.
Algoritm
1. Declarăm un vector v, care este inițial fără nici un element (k = 0), k reprezintă numărul de
elemente din vectorul v
2. Cât timp se află elemente în ambii vectori (i <= n și j <= m):
a. Compară elementul x[i] cu y[j]
b. Incrementăm k
c. Adaugăm în v, pe poziția k, elementul cel mai mic dintre x[i] și y[j]
d. Incrementăm indicele corespunzător vectorului din care am făcut adăugarea (incrementăm i dacă
elementul x[i] a fost mai mic, în caz contrar, incrementăm j)
3. Verificăm în care dintre cei doi vectori au mai rămas elemente.
a. Dacă i <= n atunci înseamnă că mai avem elemente în vectorul x[i], pe care le luam în ordine și
le adaugăm la finalul vectorului.
b. Daca j <= m atunci înseamnă că mai avem elemente în vectorul y[j], pe care le luam în ordine și
le adaugăm la finalul vectorului v.
4. Algoritmul se încheie, iar vectorul v conține elementele din x și din y ordonate crescător, vom
avea n+m elemente

#include <iostream>
using namespace std;
int main()
{ int X[100], Y[100], V[200], n, m, k = 0, i = 0, j = 0;
cout << "Introduceti numarul de elemente corespunzator vectorului X: "; cin >> n;
cout << "Introduceti elementele vectorului X: ";
for(int i = 0; i < n; i++) cin >> X[i];
 cout << "Introduceti numarul de elemente corespunzator vectorului Y: "; cin >> m;
cout << "Introduceti elementele vectorului Y: ";
for(int i = 0; i < m; i++)
cin >> Y[i];
while(i < n && j < m)
{if(X[i] < Y[j])
{ V[k] = X[i]; 10
k++; i++; }
else
{ V[k] = Y[j];
k++; j++; } }
if(i <= n)
{for(int p = i; p < n; p++)
{ V[k] = X[p]; k++; } }
if(j <= m)
{ for(int p = j; p < m; p++)
{ V[k] = Y[p]; k++; } }
for(int p = 0; p < k; p++)
cout << V[p] << " ";
return 0;}

Ordonarea elementelor unui vector sau sortarea – presupune aranjarea elementelor unui vector
după un anumit criteriu (crescător, descrescător, alfabetic). Există mai multe metode de sortare bazate pe
algoritmi diferiți:
• Sortarea prin metoda bulelor – această metodă presupune parcurgerea vectorului și se compară
fiecare element cu cel care urmează după el. Dacă cele două elemente nu sunt în ordine se interschimbă
între ele. Vectorul se parcurge de mai multe ori până când nu mai are loc nicio interschimbare (vectorul
este sortat).
Pentru a ști când nu mai are loc nicio interschimbare folosim o variabilă logică care la fiecare nouă
parcurgere a vectorului are inițial valoarea TRUE (1- presupunem că vectorul este sortat) și care la fiecare
interschimbare va lua valoarea FALSE (0 – vectorul nu este sortat deoarece are loc o interschimbare). Când
vectorul este sortat această variabilă va avea valoarea TRUE (1) la sfârșitul algoritmului.
Se consideră următorul vector de dimensiune 5:

v= 103 45 27 215 92
i 1 2 3 4 5
Pentru sortarea vectorului prin metoda bulelor se parcurg următorii pași:
Parcurgerea 1:
Variabila ok=1
➢ i=1 și comparăm elementele v[1] cu v[2] (v[1]=103>v[2]=45 adevărat, deci cele două valori se
interschimbă între ele) și variabila ok=0
v = 103 45 27 215 92 v = 45 103 27 215 92
i 1 2 3 4 5 i 1 2 3 4 5

➢ i=2 și comparăm elementele v[2] cu v[3] (v[2]=103>v[3]=27 adevărat, deci cele două valori se
interschimbă între ele) și variabila ok=0
v = 45 103 27 215 92 v = 45 27 103 215 92
i 1 2 3 4 5 i 1 2 3 4 5
➢ i=3 și comparăm elementele v[3] cu v[4] (v[3]=103>v[4]=215 fals, deci se trece la următorul i
v = 45 27 103 215 92
i 1 2 3 4 5

➢ i=4 și comparăm elementele v[4] cu v[5] (v[4]=215>v[5]=92 adevărat, deci cele două valori se
interschimbă între ele) și variabila ok=0
v = 45 27 103 215 92 v = 45 27 103 92 215 11
i 1 2 3 4 5 i 1 2 3 4 5

Cum după prima parcurgere variabila ok=0 se trece la o nouă parcurgere.

Parcurgerea 2:
Variabila ok=1
➢ i=1 și comparăm elementele v[1] cu v[2] (v[1]=45>v[2]=27 adevărat, deci cele două valori se
interschimbă între ele) și variabila ok=0
v = 45 27 103 92 215 v = 27 45 103 92 215
i 1 2 3 4 5 i 1 2 3 4 5

➢ i=2 și comparăm elementele v[2] cu v[3] (v[2]=45>v[3]=103 fals, deci se trece la următorul i
v = 27 45 103 92 215
i 1 2 3 4 5

➢ i=3 și comparăm elementele v[3] cu v[4] (v[3]=103>v[4]=92 adevărat, deci cele două valori se
interschimbă între ele) și variabila ok=0
v = 27 45 103 92 215 v = 27 45 92 103 215
i 1 2 3 4 5 i 1 2 3 4 5

➢ i=4 și comparăm elementele v[4] cu v[5] (v[4]=103>v[5]=215 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5

Cum după a doua parcurgere variabila ok=0 se trece la o nouă parcurgere.

Parcurgerea 3:
Variabila ok=1
➢ i=1 și comparăm elementele v[1] cu v[2] (v[1]=27>v[2]=45 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5
➢ i=2 și comparăm elementele v[2] cu v[3] (v[2]=45>v[3]=92 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5
➢ i=3 și comparăm elementele v[3] cu v[4] (v[3]=92>v[4]=103 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5
➢ i=4 și comparăm elementele v[4] cu v[5] (v[4]=103>v[5]=215 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5
Cum după acestă parcurgere variabila ok=1 înseamnă că vectorul este ordonat.

Să se scrie un algoritm care ordonează crescător un vector cu n elemente numere naturale.

Algoritmul:
#include <iostream>
using namespace std;
int n,i,v[101],ok=0,aux; 12
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
while (ok==0)
{ok=1;
for(i=1;i<n;i++)
if(v[i]>v[i+1]){aux=v[i];
v[i]=v[i+1];
v[i+1]=aux;
ok=0;}}
for(i=1;i<=n;i++)
cout<<v[i]<<" ";
return 0;}

• Sortarea prin selecție directă - această metodă constă în a compara primul element (v[1]) pe rând
cu toate elementele de după el şi dacă ordinea de sortare nu este respectată, cele două elemente se
interschimbă. După efectuarea tuturor comparaţiilor, în prima poziţie ajunge cel mai mic element din vector
(în cazul ordonării crescătoare). Se compară apoi al doilea element cu toate elementele de după el etc. La
ultimul pas se compară numai ultimele două elemente.
Se consideră următorul vector de dimensiune 5:
v= 103 45 27 215 92
i 1 2 3 4 5

Pentru sortarea vectorului prin selecție directă se parcurg următorii pași:

➢ Pentru i=1 luăm toate elementele începând cu poziția 2 și le comparăm cu v[1]
▪ v[1]=103>v[2]=45 adevărat, deci cele două valori se interschimbă între ele
v = 103 45 27 215 92 v = 45 103 27 215 92
i 1 2 3 4 5 i 1 2 3 4 5

▪ v[1]=45>v[3]=27 adevărat, deci cele două valori se interschimbă între ele

v= 45 103 27 215 92 v = 27 103 45 215 92
i 1 2 3 4 5 i 1 2 3 4 5

▪ v[1]=27>v[4]=215 fals, deci se trece la urrmătoarea poziție

v= 27 103 45 215 92
i 1 2 3 4 5

▪ v[1]=27>v[5]=92 fals, deci se trece la al doilea element din vector

v= 27 103 45 215 92
i 1 2 3 4 5
 În acest moment elementul cel mai mic se află pe poziția finală.

➢ Pentru i=2 luăm toate elementele începând cu poziția 3 și le comparăm cu v[2]

▪ v[2]=103>v[3]=45 adevărat, deci cele două valori se interschimbă între ele
v = 27 103 45 215 92 v = 27 45 103 215 92
i 1 2 3 4 5 i 1 2 3 4 5
13
▪ v[2]=45>v[3]=103 fals, deci se trece la urrmătoarea poziție
v= 27 45 103 215 92
i 1 2 3 4 5

▪ v[2]=45>v[4]=215 fals, deci se trece la urrmătoarea poziție

v= 27 45 103 215 92
i 1 2 3 4 5

▪ v[2]=45>v[5]=92 fals, deci se trece la al treilea element din vector

v= 27 45 103 215 92
i 1 2 3 4 5

În acest moment elementul de pe poziția 2 se află pe poziția finală.

➢ Pentru i=3 luăm toate elementele începând cu poziția 4 și le comparăm cu v[3]
▪ v[3]=103>v[4]=215 fals, deci se trece la urrmătoarea poziție
v = 27 45 103 215 92
i 1 2 3 4 5

▪ v[3]=103>v[5]=92 adevărat, deci cele două valori se interschimbă între

v= 27 45 103 215 92 v = 27 45 92 215 103
i 1 2 3 4 5 i 1 2 3 4 5

➢ Pentru i=4 luăm toate elementele începând cu poziția 5 și le comparăm cu v[4]

▪ v[4]=215>v[5]=103 adevărat, deci cele două valori se interschimbă între
v = 27 45 92 215 103 v = 27 45 92 103 215
i 1 2 3 4 5 i 1 2 3 4 5

În acest moment vectorul este sortat crescător.

Algoritmul:
#include <iostream>
using namespace std;
int main (){
int n, v[100], i, j, k, aux, minim;
cout<<"Dimensiunea vectorului: ";
cin>>n;
for (i=1;i<=n;i++) cin>>v[i];

for (i=1;i<=n-1;i++){
minim=v[i];
k=i;
for (j=i+1;j<=n;j++)
if (v[j]<minim){
minim=v[j];
13
 k=j;
}
aux=v[k];
v[k]=v[i];
v[i]=aux;
}
for (i=1;i<=n;i++) 14
cout<<v[i]<<" ";
return 0;}

• Sortarea prin numărare – metoda constă în construirea unui nou vector auxiliar C care are aceiași
dimensiune cu vectorul A și în care se vor memora elementele din A, apoi un vector Bcare inițial are
valoarea 0 și în care numărăm pentru fiecare element din A câte elemente mai mici ca el există în vector.
La finalul algoritmului se vor rescrie în ordine crescătoare elementele vectorului A pe baza valorilor
memorate în B și C.
Se consideră următorul vector de dimensiune 5:
A= 103 45 27 215 92
i 1 2 3 4 5

Pentru sortarea vectorului prin numărare se parcurg următorii pași:

Construim vectorul C în care memorăm valorile din vectorul A și vectorul B.

C= 103 45 27 215 92 B= 0 0 0 0 0
i 1 2 3 4 5 i 1 2 3 4 5

Determinăm elementele vectorului B astfel: B[i]= câte elemente mai mici decat A[i] sunt în
vectorul A.

Pe poziția 1 memorăm valoarea 3 deoarece în vectorul A avem 3 element mai mici decât v[1]=103
(avem 45, 27, 92 mai mici decât 103)
A= 103 45 27 215 92 B= 3 0 0 0 0
i 1 2 3 4 5 i 1 2 3 4 5

Pe poziția 2 memorăm valoarea 1 deoarece în vectorul A avem 1 element mai mic decât v[2]=45
(avem 27 mai mic decât 45)
A= 103 45 27 215 92 B= 3 1 0 0 0
i 1 2 3 4 5 i 1 2 3 4 5

Pe poziția 3 memorăm valoarea 0 deoarece în vectorul A avem 0 elemente mai mici decât v[3]=27

A= 103 45 27 215 92 B= 3 1 0 0 0
i 1 2 3 4 5 i 1 2 3 4 5

Pe poziția 4 memorăm valoarea 4 deoarece în vectorul A avem 4 element mai mici decât v[4]=215
(avem 103, 45, 27, 92 mai mici decât 215)

A= 103 45 27 215 92 B= 3 1 0 4 0
i 1 2 3 4 5 i 1 2 3 4 5
 Pe poziția 5 memorăm valoarea 2 deoarece în vectorul A avem 2 element mai mici decât v[5]=92
(avem 45, 27 mai mici decât 92)
A= 103 45 27 215 92 B= 3 1 0 4 2
i 1 2 3 4 5 i 1 2 3 4 5

Avem următorii vectori B și C: 15

C= 103 45 27 215 92 B= 3 1 0 4 2
i 1 2 3 4 5 i 1 2 3 4 5

Se completează elementele vectorului A astfel: A[B[i]+1]=C[i].

A= 27 45 92 103 215
i 1 2 3 4 5

Algoritmul:
#include <iostream>
using namespace std;
int n, A[100], B[100], C[100], i, j;
int main ()
{
cout<<"Dimensiunea vectorului: ";
cin>>n;
for (i=1;i<=n;i++) cin>>A[i];
for (i=1;i<=n;i++) C[i]=A[i];
for (i=1;i<n;i++)
for (j=i+1;j<=n;j++)
if (A[i]<A[j])
B[j]++;
else B[i]++;
for (i=1;i<=n;i++)
A[B[i]+1]=C[i];
for (i=1;i<=n;i++)
cout<<A[i]<<" ";
return 0;}

• Sortarea prin inserție – metoda constă în inserarea unui anumit element în șirul deja sortat al
predecesorilor săi. La fiecare pas un element este extras din vectorul iniţial şi este introdus în vectorul de
elemente sortate. Elementul este inserat în poziţia corectă în vectorul sortat, astfel încât vectorul să rămână
sortat în continuare.
Elementul aflat pe poziţia v[2] se compară cu v[1] şi încercăm să găsim poziţia în care ar trebui să
se introducă. Dacă v[2] < v[1] atunci v[2] trebuie să fie înainte, deci îl mutăm pe v[1] pe poziţia următoare.
La un pas j avem vectorul sortat v[1],...,v[j-1] şi încercăm să-l inserăm pe v[j] astfel încât să păstrăm
vectorul ordonat între 1 şi j-1.
Pentru aceasta, se compară succesiv v[j] cu elementele v[j-1], v[j-2], ..., v[1] (în această ordine),
mutând elementul de la poziţia curentă cu o poziţie la dreapta atunci când v[i]>v[j].
Când v[i]<=v[j] procesul de inserţie se opreşte, poziţia la care se realizează inserarea fiind i+1.
 Se consideră următorul vector de dimensiune 5:

A= 103 45 27 215 92
i 1 2 3 4 5

Pentru sortarea vectorului prin inserție se parcurg următorii pași:

16
A= 103 45 27 215 92
i 1 2 3 4 5

Se păstrează primul element 103 considerandu-se un subșir deja sortat. Apoi se trece la 45 și îi
căutăm locul în subșir. Se observă că 45 este mai mic decât 103. Îl inserăm pe 45 înaintea lui 103 (mutăm
toate elementele aflate după poziția pe care vrem să inserăm cu o poziție la dreapta).

A= 103 45 27 215 92
i 1 2 3 4 5

A= 103 27 215 92 A= 45 103 27 215 92

i 1 2 3 4 5 i 1 2 3 4 5

Se trece la 27 și îi căutăm locul în subșir. Se observă că 45 este mai mic decât 27. Îl inserăm pe 27
înaintea lui 45 (mutăm toate elementele aflate după poziția pe care vrem să inserăm cu o poziție la dreapta).

A= 45 103 215 92 A= 27 45 103 215 92

i 1 2 3 4 5 i 1 2 3 4 5

Se trece la 215 și îi căutăm locul în subșir. Se observă că 215 nu este mai mic decât elementele sortate
până acum, deci nu se mută.
A= 27 45 103 215 92
i 1 2 3 4 5

Se trece la 92 și îi căutăm locul în subșir. Se observă că 92 este mai mic decât 103 și mai mare decât
45. Îl inserăm pe 92 înaintea lui 103 (mutăm toate elementele aflate după poziția pe care vrem să inserăm
cu o poziție la dreapta).

A= 27 45 103 215
i 1 2 3 4 5

A= 27 45 92 103 215
i 1 2 3 4 5
Tablouri unidimensionale

Algoritmul:
#include <iostream>
using namespace std;
int n, v[100], i, j, k, x;
int main ()
{
cout<<"Dimensiunea vectorului: ";
cin>>n;
for (i=1;i<=n;i++) cin>>v[i];
for(i=1;i<=n;i++)
{k=1;
x=v[i];
while(x>v[k])
k=k+1;
for(j=i-1;j>=k;j--)
v[j+1]=v[j];
v[k]=x;
}
for (i=1;i<=n;i++)
cout<<v[i]<<" ";
return 0;}

17