C ++ funzione di ricerca binaria Ricerca Albero ricorsivo

algoritmo:

1. Prendere nodo di dati di valore;
2. Ripetere il punto 3 al punto 5 fino a trovare il valore o andiamo oltre l'albero.
3. Se i dati è uguale al valore del nodo radice, la ricerca ha successo e terminare l'algoritmo.
4. Se i dati è inferiore al valore nodo principale, dobbiamo cercare l'albero sub sinistra.
5. Dati Else è inferiore al valore nodo principale, dobbiamo cercare l'albero sub sinistra.
6. Uscita messaggio Print "Trovato" o "Not Found".

implementazione C ++

    node* search(node* root, int data)
    {
     if (root==NULL || root->data==data) return root;

     if (root->data < data)   return search(root->right, data);

     return search(root->left, data);
   }

Ci sono molteplici problemi nel codice di ricerca:

• L'ordinamento è indietro, se i dati nodo è inferiore a quello che si cerca, si dovrebbe cercare nel ramo di destra, non il ramo di sinistra.

• Si dovrebbe restituire il risultato della chiamata ricorsiva

• E 'anche chiaro perché si passa rootper riferimento. dovrebbe invece essere passato come constpuntatore qualificato e il corpo del metodo dovrebbe essere constqualificato troppo.

Ecco un'alternativa:

template <class T>
bool BST<T>::search(const struct Node<T> *root, const T& x) const {
    if (root == NULL)
        return false;
    else
    if (root->data == x)
        return true;
    else
    if (root->data < x)
        return search(root->right, x);
    else 
        return search(root->left, x);
}

Ed ecco un semplice implementazione non ricorsiva:

template <class T>
bool BST<T>::search(const struct Node<T> *root, const T& x) const {
    while (root != NULL) {
        if (root->data == x)
            return true;
        if (root->data < x)
            root = root->right;
        else 
            root = root->left;
    }
    return false;
}