Función de búsqueda recursiva del árbol de búsqueda binaria C ++

algoritmo:

1. Tomar datos valor de nodo;
2. Repita el paso 3 al paso 5 hasta que encontremos el valor o vamos más allá del árbol.
3. Si los datos es igual al valor del nodo raíz, la búsqueda es exitosa y terminar el algoritmo.
4. Si los datos es inferior al valor del nodo raíz, tenemos que buscar el árbol secundario hacia la izquierda.
5. datos de los demás es inferior al valor del nodo raíz, tenemos que buscar el árbol secundario hacia la izquierda.
6. Salida de mensaje de impresión "encontrado" o "no encontrado".

aplicación 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);
   }

Hay varios problemas en su código de búsqueda:

• El orden es al revés, si los datos de nodo es menos de lo que usted busca, usted debe buscar en la rama derecha, no la rama izquierda.

• Usted debe devolver el resultado de la llamada recursiva

• También está claro por qué se pasa rootpor referencia. en su lugar se debe pasar como un constpuntero calificado y el cuerpo del método debe ser constcalificado también.

Aquí hay una 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);
}

Y aquí es una implementación más simple no recursiva:

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;
}