Cautarea ta binara e gresita

Cosmin Negruseri
07 ianuarie 2012

Cautarea binara e probabil primul algoritm studiat de elevii sau studentii la informatica care exemplifica tehnica divide and conquer. Ea rezolva problema gasirii unui element x in un sir sortat A. Ideea de baza e simpla: folosindu-ne de monotonia datelor putem reduce la fiecare pas problema la jumatate. Totusi aproape fiecare concurent olimpiada de informatica are cate o poveste cum a bushit o problema din cauza unei cautari binare. La fel majoritatea programatorilor ce termina facultatea de informatica nu reusesc sa scrie o cautare binara fara probleme.

Buguri frecvente:

O implementare poate avea gramada de probleme cum ar fi:

• ciclu infinit
• conditii gresite de terminare
• probleme siruri de scurte de lungime 0, 1, 2
• probleme pentru siruri in care x nu exista sau x apare de mai multe ori
• probleme cand x apare in apropiere de inceputul sau finalul sirului

Optimizari premature

Am vazut tot felul de variante, de exemplu unii testeaza daca a[mid] e egal cu x si scurt circuiteaza cautarea. Aceasta optimizare nu ajuta in cazul general, doar complica codul. Alta varianta e ca poti reduce ceva mai mult problema folosind hi = mid - 1 sau lo = mid + 1. Ai un pas logic in plus la care trebuie sa fi atent. Pe langa asta cazurile in care ajungem la una din marginile sirului pot deveni mai dificile.

Variante:
Problema poate aparea in versiuni diferite cu ar fi gasirea primei sau ultimei aparitii a lui x in sirul sortat, gasirea predecesorului sau succesorului valorii x in sir. Astfel ar fi utila o metoda care poate fi adaptata usor la astfel de cerinte.

O solutie folosita frecvent de membrii infoarena foloseste puterile lui 2. Codul e elegant:

int binary_search(int A, int x) {
  int i, step, N = A.length;
  for (step = 1; step < N; step <<= 1);
  for (i = 0; step; step >>= 1)
    if (i + step < N && A[i + step] <= x)
    i += step;
  return i;
}

Mie nu imi place aceasta varianta. Un dezavantaj e ca un programator are nu stie trucul intelege codul de mai sus mai greu. Nu am incercat sa vad cat de flexibila e solutia pentru variantele problemei de care vorbeam mai sus.

Cum sa implementezi o cautare binara corecta:

Folosim un invariant in bucla cautarii binare, adica o asertiune care e adevarata de fiecare data cand intram in bucla. Pentru cazul nostru acest invariant e ca lo indica spre un element care e mai mic ca x sau spre -1 si hi indica spre un element mai mare sau egal cu x sau in A.length. Pe scurt (consideram si )

Sa vedem cum arata codul:

int search(int[] A, int x) {
    int hi = A.length, lo = -1, mid;
    while (hi - lo > 1) {
      mid = (lo + hi) / 2;
      if (A[mid] < x)
        low = mid;
       else
         hi = mid;
    }
    if (hi == A.length || A[hi] != x)
        return -1;
    else
        return hi;
}

• linia 2: setam pe hi si lo inafara sirului, astfel invariantul e indeplinit si nu trebuie sa tratam cazuri speciale.
• linia 3: conditia de continuare a buclei e hi - lo > 1. Invariantul ales face ca hi si lo sa fie tot timpul distincte. La fiecare pas distanta intre hi si lo se injumatateste, iar cand hi si lo ajung consecutive ca pozitii in sir putem lua o decizie.
• linia 4: mid va fi tot timpul intre lo si hi.
• linia x: stim ca A[mid] < x si astfel facand atribuirea lo = mid micsoram spatiu de cautare si pastra invariantul
• la linia y stim ca A[mid] >= x si putem face atribuirea hi = mid.
• la linia z vedem daca x e in sir
  • in caz afirmativ putem sa returnam indexul hi
  • un caz negativ e cand ultimul element din sir e mai mic decat x. Atunci avem lo = A.length - 1 si hi = A.length
  • celalalt caz negativ e ca hi sa fie undeva in interiorul sirului si sa avem ca A[lo] < x < A[hi]

Folosind un invariant am demonstrat corectitudinea cautarii.

Variante:
Ideea e foarte flexibila. Alt avantaj e ca folosind invarianti pentru cautarea binara, scriind algoritmul ii si demonstrati corectitudinea :).

Aceasta abordare e detaliata in cartea Programming Pearls de Jon Bentley.

Liknbaitul din titlu :)

Daca v-a sarit in ochi afirmatia din titlu, va mai zic ca in 2006, Joshua Bloch, cel care a scris algoritmul de cautare binara in java.util.Arrays a descoperit un bug in implementare. Acest bug care aparea in majoritatea cautarilor binare sau a sortarilor prin interclasare scrise in ultimii 20 de ani. Lucrand la Google el a ajuns sa sorteze siruri de doua miliarde de numere. Astfel pasul mid = (lo + hi) / 2 a ajuns sa depaseasca Integer.MAX_VALUE care e 2147483647. Putem rezolva bugul folosind in loc de .

In urmatorul articol voi discuta ce probleme pot aparea la cautarea binara pe numere reale sau metoda bisectiei cum mai e numita.

Voi ati avut vreodata probleme cu cautarile binare? Ce varianta folositi?