# Urmărirea funcțiilor recursive cu afișări

> Pagina: https://bacalaurescu.ro/informatica/lectii/recursivitate/urmarirea-functiilor-recursive
> Markdown: https://bacalaurescu.ro/informatica/lectii/recursivitate/urmarirea-functiilor-recursive.md
> Sursa: Bacalaurescu (bacalaurescu.ro), conținut gratuit pentru BAC 2027.

Materia: [Informatică](https://bacalaurescu.ro/informatica)

Capitolul: [Recursivitate](https://bacalaurescu.ro/informatica/lectii/recursivitate)
Actualizat: 2026-11-01

Tehnica sigură pentru subiectele 'ce afișează': afișări la coborâre vs la întoarcere.

## Pe scurt pentru BAC

- Afișarea doar înainte de autoapel dă numerele descrescător, `3 2 1`, iar afișarea doar după autoapel le dă crescător, `1 2 3`.
- La `g(4)`, parele se afișează la coborâre, iar imparele la întoarcere, deci rezultatul este `4 2 1 3`.
- La funcțiile cu două autoapeluri, ca `fib`, desenezi arborele de apeluri, iar frunzele lui dau `fib(4) = 3`.
- Scrie apelurile în coloană, cu indentare pentru adâncime, și marchează cu săgeți coborârea și întoarcerea.

## Regula de aur

Într-o funcție recursivă, instrucțiunile de DINAINTEA autoapelului se execută la COBORÂRE (în ordinea apelurilor), iar cele de DUPĂ autoapel se execută la ÎNTOARCERE (în ordine INVERSĂ).

## Exemplul canonic

```cpp
void f(int n) {
    if (n > 0) {
        cout << n << " ";
        f(n - 1);
        cout << n << " ";
    }
}
```

Pentru `f(3)` se afișează: **3 2 1 1 2 3**.

Coborâre (înainte de autoapel): 3, 2, 1; apoi f(0) nu face nimic; întoarcere (după autoapel): 1, 2, 3.

## Variațiile care pică la BAC

**1. Doar înainte** → numerele descrescător: `3 2 1`.

**2. Doar după** → crescător: `1 2 3` (afișarea "amânată" până la întoarcere).

**3. Cu condiție de paritate:**

```cpp
void g(int n) {
    if (n > 0) {
        if (n % 2 == 0) cout << n << " ";
        g(n - 1);
        if (n % 2 == 1) cout << n << " ";
    }
}
```

Pentru `g(4)`: coborâre afișează parele (4, 2), întoarcere afișează imparele în ordine inversă a coborârii (1, 3): rezultat **4 2 1 3**.

## Tehnica arborelui de apeluri (pentru două autoapeluri)

```cpp
int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}
```

`fib(4)`: desenezi arborele: fib(4) → fib(3) + fib(2); fib(3) → fib(2)+fib(1); fib(2) → fib(1)+fib(0). Frunzele dau 1,0,1,1,0 → `fib(4) = 3`. Numărul de apeluri: 9 (inclusiv rădăcina): la subiectele "de câte ori se apelează", numeri NODURILE arborelui.

> [!ATENTIE]
> Scrie apelurile în coloană, cu indentare pentru adâncime, și marchează cu săgeți coborârea și întoarcerea. Fără schema pe hârtie, cazurile cu afișare dublă (înainte + după) se greșesc aproape garantat.

> [!RETINE]
> Ce e scris ÎNAINTE de autoapel se execută la coborâre, în ordinea apelurilor; ce e scris DUPĂ se execută la întoarcere, în ordine inversă. De aceea `f(3)` afișează `3 2 1 1 2 3`. La două autoapeluri numeri nodurile arborelui: `fib(4)` face 9 apeluri.

## Greșeli frecvente

1. Afișările de după autoapel apar în ordine INVERSĂ: cel mai adânc apel se "întoarce" primul.
2. Condiția de oprire nu afișează nimic dacă e `if (n > 0) {...}` fără ramură else.
3. La două autoapeluri, ordinea e stânga complet, apoi dreapta: nu "în paralel".