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?
- Bazele de date – găsește un utilizator după username
- Sisteme de fișiere – găsește un fișier pe hard disk
- Motoare de căutare – găsește pagini web relevante
- Jocuri – găsește cel mai apropiat inamic
- 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.
Leave a Reply