Tablouri unidimensionale

Un tablou unidimensional memorează elemente de același tip, accesate prin indici. Pentru int v[3] = {4, 7, 2};, indicii sunt 0, 1, 2; v[1] este 7. Dimensiunea declarată este capacitatea acestui tablou C++, iar numărul elementelor folosite trebuie urmărit separat dacă nu sunt utilizate toate.

În Python, v=[4,7,2] este o listă; v[0] este 4, iar v[2] este 2. Indicii pornesc de la zero.

Vectori

Un tablou unidimensional (vector) memorează un număr fix de elemente de același tip, în locații consecutive din memorie, accesate prin indici. În C++, declarația int v[3] = {4, 7, 2}; creează trei elemente, cu indicii 0, 1 și 2, iar v[1] este 7. Dimensiunea declarată este capacitatea; numărul de elemente utile $n$ se păstrează separat. Indicele valid este cuprins între 0 și $n-1$: un indice din afara acestui interval nu produce o eroare de compilare, dar accesul este nedefinit și poate citi sau modifica memorie care aparține altei variabile. Citirea se face într-un ciclu, cin >> n; for (int i = 0; i < n; ++i) cin >> v[i];. Dacă se lucrează cu indici de la 1, tabloul se declară cu cel puțin $n+1$ poziții, iar ciclul merge de la 1 la $n$. În Python, v = [4, 7, 2] este o listă, v[0] este 4, v[-1] este ultimul element, iar len(v) dă numărul de elemente.

Parcurgerea cu for permite calculul sumei, minimului și maximului, numărarea elementelor care respectă o condiție și verificarea unei proprietăți pentru fiecare element.

Inserări, ștergeri și deplasări

Ca să ștergi un element, muți spre stânga cu o poziție tot ce urmează după el; ca să inserezi, muți întâi spre dreapta, începând de la ultimul element, ca să nu suprascrii nimic. Inversarea unui vector interschimbă v[i] cu v[n - 1 - i] până la mijloc.

Vectorul de frecvență

Când valorile sunt naturale și mici, un al doilea vector numără aparițiile fiecărei valori. Îl folosești la sortarea prin numărare, la găsirea valorii care apare cel mai des sau la verificarea faptului că două numere au aceleași cifre. Ciurul lui Eratostene folosește aceeași idee, cu un vector de marcaje (ciurul lui Eratostene).

Căutarea și sortarea

Căutarea secvențială compară, pe rând, fiecare element cu valoarea căutată. Într-un vector sortat, căutarea binară înjumătățește la fiecare pas zona în care poate fi valoarea. Metodele de ordonare sunt în capitolul Sortare. Interclasarea unește doi vectori sortați într-unul singur, tot sortat, comparând de fiecare dată primele elemente rămase.

Matrice

O matrice are n linii și m coloane, iar elementul a[i][j] este pe linia i și coloana j. O matrice cu n = m se numește pătratică și are două diagonale. Zonele matricei se descriu prin relații între i și j, iar multe probleme cer completarea unei matrice după o regulă, ceea ce se rezolvă găsind formula elementului în funcție de i și j. Matricea de adiacență a unui graf este tot o matrice pătratică (Grafuri).

Un exemplu cu indici de la 0

#include <iostream>
using namespace std;
int main() {
    int v[3] = {4, 7, 2};
    int suma = 0;
    for (int i = 0; i < 3; ++i)
        suma += v[i];
    cout << suma;
    return 0;
}

Sumele parțiale sunt 4, 11 și 13, deci se afișează 13. Accesul v[i] cere $0\le i<3$; dacă ciclul ar avea condiția i <= 3, ar citi v[3], element care nu aparține tabloului.

Exemplul 2 — minimul și poziția lui. Pentru vectorul $4,1,5,1,9$ se caută cea mai mică valoare și indicele primei ei apariții. Se pornește cu mn = v[0] și poz = 0; comparațiile v[i] < mn sunt stricte, deci o valoare egală cu minimul nu schimbă poziția. La $i=1$, valoarea 1 este mai mică decât 4 și minimul devine 1 cu poziția 1; la $i=3$, valoarea 1 nu este strict mai mică decât 1, deci poziția rămâne 1. Se afișează 1 1.

Exemplul 3 — inversarea unui vector. Elementele se inversează schimbând între ele perechile simetrice: primul cu ultimul, al doilea cu penultimul și așa mai departe, cât timp indicele din stânga este mai mic decât cel din dreapta. Pentru vectorul $4,1,5,1,9$ se fac două schimburi, $(0;4)$ și $(1;3)$, iar elementul din mijloc rămâne pe loc. Rezultatul este $9,1,5,1,4$.

for (int i = 0, j = n - 1; i < j; ++i, --j) {
    int aux = v[i];
    v[i] = v[j];
    v[j] = aux;
}

Fără variabila aux, o valoare s-ar pierde la prima atribuire. Dacă ciclul ar merge până la $n-1$, fiecare pereche ar fi schimbată de două ori și vectorul ar reveni la forma inițială.

Exemplul 4 — ștergerea unui element. Din vectorul $4,1,5,1,9$, cu $n=5$, se șterge elementul de pe poziția $p=2$, adică 5. Fiecare element de după $p$ se mută cu o poziție la stânga, iar numărul elementelor utile scade.

for (int i = p; i < n - 1; ++i)
    v[i] = v[i + 1];
--n;

Se fac $n-1-p=2$ mutări: v[2] primește 1, apoi v[3] primește 9. Vectorul util este $4,1,1,9$, cu $n=4$. Dacă $p=n-1$, ciclul nu se execută deloc și ștergerea ultimului element înseamnă doar --n. Pentru $p=0$ se fac 4 mutări și rezultatul este $1,5,1,9$. Dacă ciclul ar merge până la i < n, s-ar citi v[n], în afara elementelor utile.

Exemple rezolvate

Exemplul 1: ștergere și inserare

În vectorul 3, 8, 1, 9, 4, șterge elementul de pe poziția 2, apoi inserează valoarea 7 pe poziția 1.

1. Ștergerea: 1, 9, 4 se mută cu o poziție spre stânga, iar n scade la 4: 3, 1, 9, 4.
2. Inserarea: 3, 1, 9, 4 se mută cu o poziție spre dreapta, începând cu ultimul, iar 7 intră pe poziția 1: 7, 3, 1, 9, 4.

#include <iostream>
using namespace std;

int v[101], n = 5;

void afiseaza() {
    for (int i = 1; i <= n; i++)
        cout << v[i] << " ";
    cout << "\n";
}

int main() {
    int init[] = {3, 8, 1, 9, 4};
    for (int i = 1; i <= n; i++)
        v[i] = init[i - 1];
    int k = 2;                          // stergerea de pe pozitia k
    for (int i = k; i < n; i++)
        v[i] = v[i + 1];
    n--;
    afiseaza();
    k = 1;                              // inserarea lui 7 pe pozitia k
    for (int i = n; i >= k; i--)
        v[i + 1] = v[i];
    v[k] = 7;
    n++;
    afiseaza();
    return 0;
}

Programul afișează:

3 1 9 4
7 3 1 9 4

Exemplul 2: o matrice completată după o regulă

Construiește matricea pătratică cu n = 4 linii în care a[i][j] este distanța dintre i și j, adică |i − j|, și calculează suma elementelor aflate deasupra diagonalei principale.

1. Pe diagonala principală i = j, deci elementele sunt 0; matricea este simetrică.
2. Deasupra diagonalei (i < j) sunt elementele 1, 2, 3 de pe prima linie, 1, 2 de pe a doua și 1 de pe a treia: suma este 10.

#include <iostream>
using namespace std;

int a[11][11];

int main() {
    int n = 4, s = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i > j) a[i][j] = i - j;
            else a[i][j] = j - i;
            cout << a[i][j] << " ";
            if (i < j)
                s = s + a[i][j];        // deasupra diagonalei principale
        }
        cout << "\n";
    }
    cout << s << "\n";
    return 0;
}

Programul afișează:

0 1 2 3
1 0 1 2
2 1 0 1
3 2 1 0
10

Într-un fragment, separă indicele de valoarea stocată. Pentru v[2] = v[0] + v[1], tabloul $4,7,2$ devine $4,7,11$; elementele de la indicii 0 și 1 nu se schimbă. Verifică dacă limitele buclei includ un indice invalid, mai ales când se folosește i <= n pentru un tablou cu $n$ elemente: pentru $n=100$, ciclul ar citi v[100], al 101-lea element. Când o atribuire din ciclu folosește elementul modificat la pasul anterior, valorile se propagă: la a[i + 1] = a[i] + a[i + 1] fiecare element primește suma tuturor celor dinaintea lui. Când se compară vecinii, a[i] < a[i + 1], ciclul trebuie să se oprească la i < n - 1, deci face $n-1$ comparații: pentru $3,1,4,1,5$ sunt 4 perechi, iar 2 dintre ele sunt crescătoare, $(1,4)$ și $(1,5)$. La un schimb scris fără variabilă ajutătoare, v[i] = v[j]; v[j] = v[i];, ambele poziții primesc valoarea lui v[j]: din $4,1,5,1,9$ se obține $9,1,5,1,9$, iar valoarea 4 se pierde. La inversare se fac $[n/2]$ schimburi: 2 pentru $n=5$ și 3 pentru $n=6$, caz în care nu rămâne niciun element în mijloc.

Exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

int a[5] = {3, 1, 4, 1, 5};
for (int i = 0; i < 4; ++i)
    a[i + 1] = a[i] + a[i + 1];
for (int i = 0; i < 5; ++i)
    cout << a[i] << ' ';

• a) 3 4 5 5 6
• b) 3 4 8 9 14
• c) 3 1 4 1 5
• d) 3 4 8 9 5

Răspunsul corect este b). Valoarea lui a[0] rămâne 3. Pentru $i=0$: a[1] = 3 + 1 = 4. Pentru $i=1$ se folosește noua valoare a lui a[1]: a[2] = 4 + 4 = 8. Pentru $i=2$: a[3] = 8 + 1 = 9. Pentru $i=3$: a[4] = 9 + 5 = 14. Fiecare element devine suma prefixului. Varianta a) adună doar vecinii inițiali, ca și cum atribuirile nu s-ar propaga, iar varianta c) este tabloul neschimbat.

Unde apare la examen

• Bacalaureatul, informatică, matematică-informatică: programa de examen cuprinde tipul tablou, la tipurile structurate de date, și, la algoritmii elementari, metodele de ordonare, interclasarea și căutarea secvențială și binară (programa de examen, anexa 2 la OMECTS 4800/2010). La sesiunea din iunie–iulie 2026, ultimul exercițiu al Subiectului al II-lea a cerut completarea unei secvențe care umple o matrice 5 × 5 după o regulă dată prin exemplu (subiectele și baremele Bac 2026).
• Programa școlară: pe programa veche, tablourile uni- și bidimensionale, căutarea, sortarea și interclasarea sunt la clasa a X-a (programa de clasa a X-a, OMECI 5099/2009); pe programa nouă de clasa a IX-a, listele se memorează cu clasa list din Python (OMEC 6930/2025, anexa 42).

Greșeli frecvente

• Greșit: într-un tablou cu 3 elemente, v[3] este ultimul element.
  Corect: ultimul este v[2]; indicii valizi sunt 0, 1 și 2.
• Greșit: dimensiunea declarată este întotdeauna numărul de elemente folosite.
  Corect: ea este capacitatea; numărul elementelor utile se păstrează separat.
• Greșit: la inversarea unui vector se parcurge tot vectorul cu schimburi.
  Corect: se parcurge doar prima jumătate, altfel fiecare pereche ar fi schimbată de două ori.
• Greșit: primul element este întotdeauna v[1].
  Corect: în tablourile C++ indexate obișnuit, este v[0]; convenția de la 1 cere un tablou cu cel puțin n + 1 poziții.
• Greșit: modificarea lui v[2] schimbă automat și v[0].
  Corect: pozițiile sunt distincte.

Înainte și după

Întrebări frecvente