Algoritmi de Căutare într-un Vector: Cum Găsești Acul în Carul cu Fân – Materie BAC

Bun, hai să vorbim despre una dintre cele mai practice și folosite operații cu vectori: CĂUTAREA. Nu e doar despre găsire (cuvânt simplu) și identificare. E despre cum localizezi rapid ce ai nevoie într-o mare de date. E o abilitate atât de importantă încât dacă ar fi să cauți manual în 1.000.000 de elemente, ți-ar lua o viață. Dar aici intervine și partea inteligentă: alegerea algoritmului potrivit pentru situația ta.

1. De ce Avem Nevoie de Algoritmi de Căutare? “Sherlock Holmes vs Turma de Oi”

Gândește-te la căutare ca la găsirea unui prieten într-un stadion plin: poți striga numele lui (căutare liniară) sau poți ști că e în sectorul B, rândul 5, locul 12 (căutare binară dacă stadionul e sortat).

De ce sunt importanți algoritmii de căutare?

1. Bazele de date – găsește un utilizator după username
2. Sisteme de fișiere – găsește un fișier pe hard disk
3. Motoare de căutare – găsește pagini web relevante
4. Jocuri – găsește cel mai apropiat inamic
5. Aplicații de contacte – găsește un nume în agendă

Analogie cu o Bibliotecă:

Căutare liniară: Mergi la fiecare raft, te uiți la fiecare carte
Căutare binară: Știi că cărțile sunt sortate alfabetic, mergi direct la litera potrivită

2. Căutarea Liniară (Linear Search): “Verifică Toate, Una Câte Una”

Cum funcționează: Verifici fiecare element din vector până găsești ce cauți sau până ajungi la sfârșit.

#include <iostream>
using namespace std;

int main() {
    int v[] = {23, 45, 12, 67, 89, 34, 56, 78, 90, 11};
    int n = 10;  // Numărul de elemente

    cout << "Vector: ";
    for(int i = 0; i < n; i++) {
        cout << v[i] << " ";
    }
    cout << endl;

    int elementCautat;
    cout << "\nCe element cauti? ";
    cin >> elementCautat;

    // Căutare liniară
    bool gasit = false;
    int pozitie = -1;
    int pasi = 0;  // Contor pentru câte verificări facem

    for(int i = 0; i < n; i++) {
        pasi++;  // Am făcut o verificare
        if(v[i] == elementCautat) {
            gasit = true;
            pozitie = i;
            break;  // Ieșim imediat când l-am găsit
        }
    }

    // Afișare rezultate
    if(gasit) {
        cout << "✓ Elementul " << elementCautat << " a fost gasit pe pozitia " << pozitie << endl;
    } else {
        cout << "✗ Elementul " << elementCautat << " NU a fost gasit in vector!" << endl;
    }

    cout << "Am facut " << pasi << " verificari" << endl;
    cout << "Complexitate: O(n) - in cel mai rau caz verificam toate cele " << n << " elemente" << endl;

    return 0;
}

Varianta cu Funcție:

#include <iostream>
using namespace std;

// Funcție care caută liniar și returnează poziția (sau -1 dacă nu găsește)
int cautaLiniar(int v[], int n, int element) {
    for(int i = 0; i < n; i++) {
        if(v[i] == element) {
            return i;  // Am găsit! Returnează poziția
        }
    }
    return -1;  // Nu am găsit
}

int main() {
    int v[] = {5, 2, 8, 1, 9, 3};
    int n = 6;

    cout << "Test cautare liniara:\n";
    cout << "Caut 8: pozitia " << cautaLiniar(v, n, 8) << endl;  // Ar trebui să returneze 2
    cout << "Caut 4: pozitia " << cautaLiniar(v, n, 4) << endl;  // Ar trebui să returneze -1

    return 0;
}

3. Căutarea Binară (Binary Search): “Împarte și Câștigă”

Cum funcționează: Funcționează DOAR pe vectori SORTAȚI! Împarte vectorul în jumătate, decide în care jumătate se află elementul, repetă până îl găsește.

#include <iostream>
using namespace std;

int main() {
    // ATENȚIE: Vectorul TREBUIE să fie sortat pentru căutarea binară!
    int v[] = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100};
    int n = 10;

    cout << "Vector SORTAT: ";
    for(int i = 0; i < n; i++) {
        cout << v[i] << " ";
    }
    cout << endl;

    int elementCautat;
    cout << "\nCe element cauti? ";
    cin >> elementCautat;

    // Căutare binară
    int stanga = 0;          // Începutul zonei de căutare
    int dreapta = n - 1;     // Sfârșitul zonei de căutare
    bool gasit = false;
    int pozitie = -1;
    int pasi = 0;

    while(stanga <= dreapta) {
        pasi++;
        int mijloc = stanga + (dreapta - stanga) / 2;  // Evită overflow

        cout << "Pasul " << pasi << ": caut intre pozitiile " << stanga 
             << " si " << dreapta << " (mijloc = " << mijloc << ")" << endl;

        if(v[mijloc] == elementCautat) {
            gasit = true;
            pozitie = mijloc;
            break;
        }

        if(v[mijloc] < elementCautat) {
            // Elementul e în dreapta
            stanga = mijloc + 1;
            cout << "  → Merg la dreapta (" << stanga << "..." << dreapta << ")" << endl;
        } else {
            // Elementul e în stânga
            dreapta = mijloc - 1;
            cout << "  → Merg la stanga (" << stanga << "..." << dreapta << ")" << endl;
        }
    }

    // Afișare rezultate
    if(gasit) {
        cout << "\n✓ Elementul " << elementCautat << " a fost gasit pe pozitia " << pozitie << endl;
    } else {
        cout << "\n✗ Elementul " << elementCautat << " NU a fost gasit in vector!" << endl;
    }

    cout << "Am facut " << pasi << " verificari" << endl;
    cout << "Complexitate: O(log n) - mult mai rapid decat O(n)!" << endl;
    cout << "Pentru " << n << " elemente, log2(" << n << ") ≈ " << log2(n) << " pasi" << endl;

    return 0;
}

Demonstrație vizuală căutare binară:

Vector sortat: [11, 22, 33, 44, 55, 66, 77, 88, 99, 100]
Căutăm elementul 77

Pasul 1: stanga=0, dreapta=9, mijloc=4, v[4]=55
77 > 55 → merg în dreapta

Pasul 2: stanga=5, dreapta=9, mijloc=7, v[7]=88  
77 < 88 → merg în stânga

Pasul 3: stanga=5, dreapta=6, mijloc=5, v[5]=66
77 > 66 → merg în dreapta

Pasul 4: stanga=6, dreapta=6, mijloc=6, v[6]=77
GĂSIT! Doar 4 pași pentru 10 elemente!

Varianta Recursivă a Căutării Binare:

#include <iostream>
using namespace std;

// Căutare binară recursivă
int cautareBinaraRecursiv(int v[], int stanga, int dreapta, int element) {
    if(stanga > dreapta) {
        return -1;  // Nu am găsit
    }

    int mijloc = stanga + (dreapta - stanga) / 2;

    if(v[mijloc] == element) {
        return mijloc;  // Am găsit!
    }

    if(v[mijloc] > element) {
        // Caută în stânga
        return cautareBinaraRecursiv(v, stanga, mijloc - 1, element);
    } else {
        // Caută în dreapta
        return cautareBinaraRecursiv(v, mijloc + 1, dreapta, element);
    }
}

int main() {
    int v[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    int n = 10;

    cout << "Cautare binara recursiva:\n";
    cout << "Caut 50: pozitia " << cautareBinaraRecursiv(v, 0, n-1, 50) << endl;
    cout << "Caut 25: pozitia " << cautareBinaraRecursiv(v, 0, n-1, 25) << endl;

    return 0;
}

4. Compararea Căutării Liniare vs Binare

#include <iostream>
#include <ctime>  // Pentru măsurarea timpului
using namespace std;

int cautaLiniar(int v[], int n, int element) {
    for(int i = 0; i < n; i++) {
        if(v[i] == element) {
            return i;
        }
    }
    return -1;
}

int cautareBinara(int v[], int n, int element) {
    int stanga = 0, dreapta = n - 1;

    while(stanga <= dreapta) {
        int mijloc = stanga + (dreapta - stanga) / 2;

        if(v[mijloc] == element) {
            return mijloc;
        }

        if(v[mijloc] < element) {
            stanga = mijloc + 1;
        } else {
            dreapta = mijloc - 1;
        }
    }

    return -1;
}

int main() {
    const int N = 1000000;  // 1 milion de elemente!
    int* v = new int[N];

    // Umple vectorul cu numere sortate
    for(int i = 0; i < N; i++) {
        v[i] = i * 2;  // Numere pare: 0, 2, 4, 6, ...
    }

    cout << "=== COMPARATIE CĂUTARE LINIARA vs BINARA ===\n";
    cout << "Vector cu " << N << " elemente sortate\n\n";

    int elementeDeCautat[] = {500000, 999998, 250000, 750000, 123456, 999999};

    for(int i = 0; i < 6; i++) {
        int element = elementeDeCautat[i];

        cout << "Caut elementul " << element << ":\n";

        // Căutare liniară
        clock_t start = clock();
        int pozLiniar = cautaLiniar(v, N, element);
        clock_t end = clock();
        double timpLiniar = double(end - start) / CLOCKS_PER_SEC;

        cout << "  Liniara: pozitia " << pozLiniar << ", timp: " << timpLiniar << " secunde\n";

        // Căutare binară
        start = clock();
        int pozBinara = cautareBinara(v, N, element);
        end = clock();
        double timpBinara = double(end - start) / CLOCKS_PER_SEC;

        cout << "  Binara:  pozitia " << pozBinara << ", timp: " << timpBinara << " secunde\n";

        cout << "  Diferența: " << timpLiniar / timpBinara << "x mai rapid cu binara!\n\n";
    }

    delete[] v;
    return 0;
}

Tabel comparativ:

Caracteristică	Căutare Liniară	Căutare Binară
Vector necesar	Orice vector	Doar vectori SORTAȚI
Complexitate	O(n)	O(log n)
Timp pentru 1.000.000 elemente	~500.000 verificări (în medie)	~20 verificări
Când să folosești	Vectori nesortați sau mici	Vectori sortați mari
Implementare	Simplă	Mai complexă
Memorie	O(1)	O(1) iterativ, O(log n) recursiv

5. Căutarea cu Sentinelă: “Un Truc Inteligent”

Cum funcționează: Pune elementul căutat la sfârșitul vectorului ca “sentinela”, ca să nu mai verifici dacă ai ajuns la sfârșit.

#include <iostream>
using namespace std;

int main() {
    int v[] = {23, 45, 12, 67, 89, 34, 56, 78};
    int n = 8;
    int elementCautat;

    cout << "Vector: ";
    for(int i = 0; i < n; i++) cout << v[i] << " ";
    cout << endl;

    cout << "\nCe element cauti? ";
    cin >> elementCautat;

    // Salvăm ultimul element
    int ultimElement = v[n-1];

    // Punem elementul căutat ca sentinelă la sfârșit
    v[n-1] = elementCautat;

    // Căutare cu sentinelă
    int i = 0;
    while(v[i] != elementCautat) {
        i++;
    }

    // Restaurăm ultimul element
    v[n-1] = ultimElement;

    // Verificăm dacă am găsit elementul sau sentinela
    if(i < n-1 || elementCautat == ultimElement) {
        cout << "✓ Elementul " << elementCautat << " a fost gasit pe pozitia " << i << endl;
    } else {
        cout << "✗ Elementul " << elementCautat << " NU a fost gasit in vector!" << endl;
    }

    cout << "Am facut " << (i+1) << " verificari" << endl;

    return 0;
}

6. Căutarea Multiplelor Apariții

#include <iostream>
using namespace std;

int main() {
    int v[] = {5, 2, 8, 2, 9, 2, 3, 2, 7, 2};
    int n = 10;

    cout << "Vector: ";
    for(int i = 0; i < n; i++) cout << v[i] << " ";
    cout << endl;

    int elementCautat;
    cout << "\nCe element cauti? ";
    cin >> elementCautat;

    // Caută TOATE aparițiile
    int pozitii[10];  // Pentru a stoca pozițiile găsite
    int gasite = 0;

    cout << "Cautare toate aparitiile lui " << elementCautat << ":\n";

    for(int i = 0; i < n; i++) {
        if(v[i] == elementCautat) {
            pozitii[gasite] = i;
            gasite++;
        }
    }

    if(gasite > 0) {
        cout << "✓ Am gasit " << gasite << " aparitii pe pozitiile: ";
        for(int i = 0; i < gasite; i++) {
            cout << pozitii[i] << " ";
        }
        cout << endl;
    } else {
        cout << "✗ Nu am gasit nici o aparitie a lui " << elementCautat << "!" << endl;
    }

    // Prima apariție
    for(int i = 0; i < n; i++) {
        if(v[i] == elementCautat) {
            cout << "Prima aparitie: pozitia " << i << endl;
            break;
        }
    }

    // Ultima apariție
    for(int i = n-1; i >= 0; i--) {
        if(v[i] == elementCautat) {
            cout << "Ultima aparitie: pozitia " << i << endl;
            break;
        }
    }

    return 0;
}

7. Căutarea în Vectori de Structuri

#include <iostream>
#include <string>
using namespace std;

struct Elev {
    int id;
    string nume;
    double medie;
};

int main() {
    Elev elevii[] = {
        {101, "Popescu Ana", 9.5},
        {102, "Ionescu Marius", 8.2},
        {103, "Georgescu Ioana", 7.8},
        {104, "Dumitrescu Andrei", 9.1},
        {105, "Stanescu Elena", 8.9}
    };
    int n = 5;

    cout << "=== CAUTARE ELEV ===\n\n";
    cout << "1. Cauta dupa ID\n";
    cout << "2. Cauta dupa nume\n";
    cout << "3. Cauta dupa medie minima\n";
    cout << "Alegerea ta: ";

    int optiune;
    cin >> optiune;

    switch(optiune) {
        case 1: {
            int idCautat;
            cout << "Introdu ID-ul elevului: ";
            cin >> idCautat;

            bool gasit = false;
            for(int i = 0; i < n; i++) {
                if(elevii[i].id == idCautat) {
                    cout << "\n✓ Elev gasit!\n";
                    cout << "ID: " << elevii[i].id << endl;
                    cout << "Nume: " << elevii[i].nume << endl;
                    cout << "Medie: " << elevii[i].medie << endl;
                    gasit = true;
                    break;
                }
            }

            if(!gasit) {
                cout << "\n✗ Nu exista elev cu ID-ul " << idCautat << endl;
            }
            break;
        }

        case 2: {
            string numeCautat;
            cout << "Introdu numele elevului: ";
            cin.ignore();
            getline(cin, numeCautat);

            bool gasit = false;
            for(int i = 0; i < n; i++) {
                if(elevii[i].nume == numeCautat) {
                    cout << "\n✓ Elev gasit!\n";
                    cout << "ID: " << elevii[i].id << endl;
                    cout << "Nume: " << elevii[i].nume << endl;
                    cout << "Medie: " << elevii[i].medie << endl;
                    gasit = true;
                    break;
                }
            }

            if(!gasit) {
                cout << "\n✗ Nu exista elev cu numele \"" << numeCautat << "\"" << endl;
            }
            break;
        }

        case 3: {
            double medieMinima;
            cout << "Introdu media minima: ";
            cin >> medieMinima;

            cout << "\nElevii cu media >= " << medieMinima << ":\n";
            int gasiti = 0;

            for(int i = 0; i < n; i++) {
                if(elevii[i].medie >= medieMinima) {
                    cout << "- " << elevii[i].nume << " (" << elevii[i].medie << ")\n";
                    gasiti++;
                }
            }

            if(gasiti == 0) {
                cout << "Niciun elev nu are media >= " << medieMinima << endl;
            } else {
                cout << "Total: " << gasiti << " elev(i)\n";
            }
            break;
        }

        default:
            cout << "Optiune invalida!" << endl;
    }

    return 0;
}

8. Căutarea Interpolată: “Căutare Binara Mai Inteligentă”

Cum funcționează: Ca căutarea binară, dar ghicește unde ar trebui să fie elementul bazat pe valorile extreme.

#include <iostream>
using namespace std;

int main() {
    // Vector cu valori uniform distribuite
    int v[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    int n = 10;

    cout << "Vector sortat uniform: ";
    for(int i = 0; i < n; i++) cout << v[i] << " ";
    cout << endl;

    int elementCautat;
    cout << "\nCe element cauti? ";
    cin >> elementCautat;

    // Căutare interpolată
    int stanga = 0;
    int dreapta = n - 1;
    bool gasit = false;
    int pasi = 0;

    while(stanga <= dreapta && elementCautat >= v[stanga] && elementCautat <= v[dreapta]) {
        pasi++;

        // Formula de interpolare - ghicește poziția
        int pozitie = stanga + ((elementCautat - v[stanga]) * (dreapta - stanga)) / 
                               (v[dreapta] - v[stanga]);

        cout << "Pasul " << pasi << ": pozitie estimata = " << pozitie 
             << " (valoare: " << v[pozitie] << ")" << endl;

        if(v[pozitie] == elementCautat) {
            gasit = true;
            cout << "✓ Gasit pe pozitia " << pozitie << endl;
            break;
        }

        if(v[pozitie] < elementCautat) {
            stanga = pozitie + 1;
        } else {
            dreapta = pozitie - 1;
        }
    }

    if(!gasit) {
        cout << "✗ Elementul " << elementCautat << " nu a fost gasit!" << endl;
    }

    cout << "Total pasi: " << pasi << endl;
    cout << "Cautarea binara ar fi facut ~" << log2(n) << " pasi" << endl;

    return 0;
}

9. PROIECT INTEGRAT: Sistem Complet de Căutare

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

// Funcții pentru diferite tipuri de căutare
int cautaLiniar(int v[], int n, int x) {
    for(int i = 0; i < n; i++) {
        if(v[i] == x) return i;
    }
    return -1;
}

int cautareBinara(int v[], int n, int x) {
    int stanga = 0, dreapta = n - 1;
    while(stanga <= dreapta) {
        int mijloc = stanga + (dreapta - stanga) / 2;
        if(v[mijloc] == x) return mijloc;
        if(v[mijloc] < x) stanga = mijloc + 1;
        else dreapta = mijloc - 1;
    }
    return -1;
}

int cautareCuSentinel(int v[], int n, int x) {
    int ultim = v[n-1];
    v[n-1] = x;

    int i = 0;
    while(v[i] != x) i++;

    v[n-1] = ultim;

    if(i < n-1 || x == ultim) return i;
    return -1;
}

void sorteazaVector(int v[], int n) {
    for(int i = 0; i < n-1; i++) {
        for(int j = 0; j < n-i-1; j++) {
            if(v[j] > v[j+1]) {
                int temp = v[j];
                v[j] = v[j+1];
                v[j+1] = temp;
            }
        }
    }
}

void afiseazaVector(int v[], int n, string mesaj) {
    cout << mesaj;
    for(int i = 0; i < n && i < 20; i++) {  // Afișează maxim 20
        cout << v[i] << " ";
    }
    if(n > 20) cout << "... (" << n << " elemente)";
    cout << endl;
}

int main() {
    const int MAX = 100000;
    int vector[MAX], copie[MAX];
    int n;

    cout << "=== SISTEM COMPLET DE CAUTARE ===\n\n";

    // Alegere dimensiune
    cout << "Dimensiune vector (max " << MAX << "): ";
    cin >> n;

    if(n <= 0 || n > MAX) {
        cout << "Dimensiune invalida!" << endl;
        return 1;
    }

    // Generare vector
    srand(time(0));
    for(int i = 0; i < n; i++) {
        vector[i] = rand() % 10000;  // Numere între 0 și 9999
        copie[i] = vector[i];
    }

    afiseazaVector(vector, n, "Vector generat (primele 20): ");

    // Meniu principal
    while(true) {
        cout << "\n=== MENIU PRINCIPAL ===\n";
        cout << "1. Cautare liniara\n";
        cout << "2. Cautare binara (va sorta vectorul)\n";
        cout << "3. Cautare cu sentinela\n";
        cout << "4. Compara algoritmii\n";
        cout << "5. Regenerare vector\n";
        cout << "0. Iesire\n";
        cout << "Alegerea ta: ";

        int optiune;
        cin >> optiune;

        if(optiune == 0) break;

        if(optiune >= 1 && optiune <= 4) {
            int elementCautat;
            cout << "Elementul de cautat: ";
            cin >> elementCautat;

            clock_t start, end;
            double timp;
            int rezultat;

            switch(optiune) {
                case 1:  // Liniară
                    start = clock();
                    rezultat = cautaLiniar(vector, n, elementCautat);
                    end = clock();
                    timp = double(end - start) / CLOCKS_PER_SEC;

                    if(rezultat != -1) {
                        cout << "✓ Gasit pe pozitia " << rezultat << endl;
                    } else {
                        cout << "✗ Nu a fost gasit" << endl;
                    }
                    cout << "Timp: " << timp << " secunde" << endl;
                    break;

                case 2:  // Binară
                    // Sortăm vectorul pentru căutarea binară
                    for(int i = 0; i < n; i++) vector[i] = copie[i];
                    start = clock();
                    sorteazaVector(vector, n);
                    rezultat = cautareBinara(vector, n, elementCautat);
                    end = clock();
                    timp = double(end - start) / CLOCKS_PER_SEC;

                    if(rezultat != -1) {
                        cout << "✓ Gasit pe pozitia " << rezultat << " (in vectorul sortat)" << endl;
                    } else {
                        cout << "✗ Nu a fost gasit" << endl;
                    }
                    cout << "Timp (inclusiv sortarea): " << timp << " secunde" << endl;
                    break;

                case 3:  // Cu sentinelă
                    for(int i = 0; i < n; i++) vector[i] = copie[i];
                    start = clock();
                    rezultat = cautareCuSentinel(vector, n, elementCautat);
                    end = clock();
                    timp = double(end - start) / CLOCKS_PER_SEC;

                    if(rezultat != -1) {
                        cout << "✓ Gasit pe pozitia " << rezultat << endl;
                    } else {
                        cout << "✗ Nu a fost gasit" << endl;
                    }
                    cout << "Timp: " << timp << " secunde" << endl;
                    break;

                case 4:  // Comparație
                    cout << "\n=== COMPARATIE ALGORITMI ===\n";

                    // Liniară
                    for(int i = 0; i < n; i++) vector[i] = copie[i];
                    start = clock();
                    rezultat = cautaLiniar(vector, n, elementCautat);
                    end = clock();
                    double timpLiniar = double(end - start) / CLOCKS_PER_SEC;

                    // Binară
                    for(int i = 0; i < n; i++) vector[i] = copie[i];
                    start = clock();
                    sorteazaVector(vector, n);
                    rezultat = cautareBinara(vector, n, elementCautat);
                    end = clock();
                    double timpBinara = double(end - start) / CLOCKS_PER_SEC;

                    // Cu sentinelă
                    for(int i = 0; i < n; i++) vector[i] = copie[i];
                    start = clock();
                    rezultat = cautareCuSentinel(vector, n, elementCautat);
                    end = clock();
                    double timpSentinel = double(end - start) / CLOCKS_PER_SEC;

                    cout << "Liniara:  " << timpLiniar << " secunde\n";
                    cout << "Binara:   " << timpBinara << " secunde (cu sortare)\n";
                    cout << "Sentinela: " << timpSentinel << " secunde\n";

                    if(timpLiniar > 0 && timpBinara > 0) {
                        cout << "\nBinara e de " << timpLiniar/timpBinara << "x mai rapida decat liniara!\n";
                    }
                    break;
            }
        }

        else if(optiune == 5) {  // Regenerare
            srand(time(0));
            for(int i = 0; i < n; i++) {
                vector[i] = rand() % 10000;
                copie[i] = vector[i];
            }
            cout << "Vector regenerat cu succes!\n";
            afiseazaVector(vector, n, "Noul vector (primele 20): ");
        }

        else {
            cout << "Optiune invalida!\n";
        }
    }

    cout << "\nLa revedere!\n";
    return 0;
}

10. Exerciții Practice

Exercițiul 1: Căutare cu Frecvență

#include <iostream>
using namespace std;

int main() {
    int v[] = {5, 2, 8, 2, 9, 5, 2, 1, 5, 2, 7, 5};
    int n = 12;

    cout << "Vector: ";
    for(int i = 0; i < n; i++) cout << v[i] << " ";
    cout << endl;

    // Crează un vector de frecvență
    const int MAX_VAL = 10;  // Presupunem valori între 0 și 9
    int frecventa[MAX_VAL] = {0};

    // Calculează frecvența fiecărui element
    for(int i = 0; i < n; i++) {
        if(v[i] >= 0 && v[i] < MAX_VAL) {
            frecventa[v[i]]++;
        }
    }

    // Căutare rapidă - direct în vectorul de frecvență
    int elementCautat;
    cout << "\nCe element cauti? ";
    cin >> elementCautat;

    if(elementCautat >= 0 && elementCautat < MAX_VAL) {
        if(frecventa[elementCautat] > 0) {
            cout << "✓ Elementul " << elementCautat << " apare de " 
                 << frecventa[elementCautat] << " ori\n";

            // Găsește prima poziție (dacă e nevoie)
            for(int i = 0; i < n; i++) {
                if(v[i] == elementCautat) {
                    cout << "Prima aparitie: pozitia " << i << endl;
                    break;
                }
            }
        } else {
            cout << "✗ Elementul " << elementCautat << " nu apare in vector!\n";
        }
    } else {
        cout << "Elementul trebuie sa fie intre 0 si " << MAX_VAL-1 << "!\n";
    }

    return 0;
}

Exercițiul 2: Căutare în Vector 2D (Matrice)

#include <iostream>
using namespace std;

int main() {
    int matrice[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    int elementCautat;
    cout << "Ce element cauti in matrice? ";
    cin >> elementCautat;

    bool gasit = false;
    int randGasit, coloanaGasita;

    // Căutare liniară în matrice
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 4; j++) {
            if(matrice[i][j] == elementCautat) {
                gasit = true;
                randGasit = i;
                coloanaGasita = j;
                break;
            }
        }
        if(gasit) break;
    }

    if(gasit) {
        cout << "✓ Elementul " << elementCautat << " a fost gasit la pozitia ("
             << randGasit << ", " << coloanaGasita << ")" << endl;
    } else {
        cout << "✗ Elementul " << elementCautat << " nu a fost gasit in matrice!" << endl;
    }

    return 0;
}

În concluzie, să-ți spun ceva fundamental:

Algoritmii de căutare nu sunt doar exerciții teoretice – sunt instrumente practice pe care le folosești în fiecare aplicație. Diferența dintre o căutare care durează 1 secundă și una care durează 1 oră poate fi alegerea algoritmului potrivit.

Dar folosirea căutării binare pe un vector nesortat poate fi, paradoxal, o sursă de bug-uri grave care îți pot distruge întreaga logică a programului dacă nu verifici dacă vectorul e sortat.

Așa că ai grijă ce algoritm alegi. Cunoștințe-ti datele: sunt sortate sau nu? Sunt multe sau puține? Cauți o singură apariție sau toate? Pentru că puterea de a găsi rapid ce cauți este goală fără înțelegerea când să folosești fiecare algoritm. Și această putere vine cu o responsabilitate: să fii strategic și precis.

Stăpânirea algoritmilor de căutare este o parte esențială a rezolvării eficiente a problemelor în programare. Ai grijă de ea cu aceeași seriozitate.