Cómo encontrar un elemento en un árbol de búsqueda binario

En el árbol de búsqueda binario (BST), siempre que el elemento exista en el árbol, definitivamente se podrá buscar en algún lugar a lo largo de la ruta desde el nodo raíz hacia abajo a todos los nodos hoja. Esto es lo que necesitamos descubrir.

Como sabemos que el árbol dado es un BST, podemos usar DFS (búsqueda de profundidad primero) o BFS (búsqueda de respiración primero) para determinar qué nodos seguir a continuación hasta que veamos el nodo con el elemento deseado. Debido a que todos los nodos en un BST deben satisfacer la condición de tener un nodo secundario izquierdo con un valor menor (datos) y un nodo secundario derecho con un valor mayor (datos).

Luego, depende de cómo el BST contiene sus nodos hijos, si se extiende ampliamente (cerca del árbol completo O completo, que tiene el número máximo de nodos para cada nivel / profundidad), entonces podemos usar BFS para encontrar el elemento dado. BFS se puede implementar usando una (1) estructura de datos de cola o (2) usando LinkedList + HashSet.

Con (1), la idea es seguir agregando los nodos secundarios izquierdo y derecho a una cola, cada vez que terminemos de verificar el nodo actual para ver si es el nodo deseado. Luego, cada vez que retiramos un nodo, repetimos el paso anterior nuevamente para atravesar el árbol. Debe estar en orden de primero en entrar, primero en salir.

Con (2), podemos usar un LinkedList para mantener el nodo que hemos atravesado hasta ahora, y luego usar un HashSet para verificar si el nodo ha sido “visitado” hasta ahora. Tenga en cuenta que queremos usar un HashSet para beneficiar la accesibilidad de tiempo O (1) cuando intentamos buscar cualquier nodo.

Además de BFS, si el BST es “alto” o “profundo”, que parece una larga lista de nodos, entonces DFS es definitivamente el candidato, ya que queremos atravesar el árbol (a la izquierda) hasta llegar al nivel inferior en lugar de todos los nodos en cada nivel. Este recorrido transversal del árbol es similar al algoritmo transversal de preorden. La implementación de DFS se puede hacer usando (1) estructura de datos de pila, o (2) recursividad.

Con (1), debe ser el último en entrar, primero en salir, ya que queremos ir tan lejos como podamos hacia abajo hasta el nivel inferior, luego volver a subir.

Con (2), la recursividad debe ser similar al algoritmo transversal de preorden.

Espero que esto te dé una mejor idea del problema.

Buena suerte.

Su consulta ” detiene la recursión de la cola una vez que la encuentra.

¡Ahora no está claro si desea recuperar el nodo del árbol de búsqueda binario o simplemente desea que se levante una bandera booleana!

Código 1: para recuperar el nodo de BST

Búsqueda de nodo público estático (raíz de nodo, int toSearch)
{
// ¡devuelve root si está vacío o coincide!
if (root == null || root.data == toSearch)
volver root;

// atraviesa el subárbol izquierdo de los datos de la raíz> elemento de búsqueda
if (root.data> toSearch)
búsqueda de retorno (root.left, toSearch);

// atraviesa el subárbol derecho de los datos de la raíz búsqueda de retorno (root.right, toSearch);
}

Código 2: ¡No recuperar el nodo cuando coincide (implementación similar)!

búsqueda estática pública booleana2 (raíz de nodo, clave int)
{
if (raíz == nulo)
falso retorno;
if (root.data == clave)
volver verdadero;

if (raíz.datos> clave)
return search2 (root.left, key);

// recursión del subárbol derecho
return search2 (root.right, key);
}

Para responder a su pregunta sobre la detención de la recursión de la cola, consulte las líneas 10 y 13.

Solo voy a suponer que está utilizando Java y tiene una clase BST genérica que tiene una variable de instancia para el nodo raíz y la clase de nodo privado tiene los métodos BST estándar de getRight (), getLeft () y getData () .

Nodo público búsqueda (datos T) {
if (datos == nulo) {
lanzar nueva IllegalArgumentException (“El argumento de datos no puede ser nulo”);
}

if (this.root == null) {
lanzar una nueva NoSuchElementException (“No existen elementos en este BST”);
}
return searchHelper (datos, this.root);
}

Nodo privado searchHelper (datos T, nodo actual) {
if (data.compareTo (current.getData ())> 0) {
return (current.getRight () == null)? nulo: searchHelper (data, current.getRight ());
} else if (data.compareTo (current.getData ()) <0) {
return (current.getLeft () == null)? nulo: searchHelper (data, current.getLeft ());
}
corriente de retorno; //encontró
}

¡Espero que esto ayude!

  1. Comience en el nodo raíz del árbol
  2. Compare el valor del nodo actual con el valor que se busca
  1. Si los valores son iguales, ya está
  2. Si el valor que se busca es menor que el valor del nodo actual …
  1. Si existe un niño izquierdo, vaya al niño izquierdo y comience el paso 2 nuevamente
  2. Si no existe un elemento secundario izquierdo, el valor no está en el árbol
  • Si el valor que se busca es mayor que el valor del nodo actual
    1. Si existe un niño correcto, vaya al niño correcto y comience el paso 2 nuevamente
    2. Si no existe un hijo correcto, el valor no está en el árbol

    El punto clave es que simplemente está verificando el valor actual y luego decidiendo si atravesar o no a un niño (y cuál).

    Para cualquier BST, los elementos en el lado derecho de la raíz serán mayores que la raíz y los elementos en el lado izquierdo serán más pequeños que la raíz. Por lo tanto, puede seguir comparando los datos con los datos de cada nodo y ver si hay una coincidencia. Puedes hacer esto usando recursividad

    public static boolean isElementPresent (raíz del nodo, int num)

    {

    if (root == null) devuelve falso;

    if (root.data == num)

    volver verdadero;

    if (root.data

    return isElementPresent (root.right, num);

    más

    return isElementPresent (root.left, num);

    }

    Escribí un método de búsqueda recursivo en Python para un BST a continuación. También tengo una versión completa de un BST si tiene curiosidad sobre cualquier otro detalle de implementación.

    Nodo de clase:
    def __init __ (self, val):
    self.val = val
    self.left = Ninguno
    self.right = Ninguno

    clase BST:
    ” ‘… __init__, insertar, eliminar, …’ ”

    def find (self, val):
    si self.root es None:
    falso retorno
    return self .__ find (self.root, val)

    def __find (self, nodo, val):
    si el nodo es Ninguno:
    devuelva False # cambie False con None si desea el nodo real)
    elif node.val == val:
    devuelva True # cambie True con el nodo si desea el nodo real)
    elif node.val> val:
    return self .__ find (node.left, val)
    más:
    return self .__ find (node.right, val)

    More Interesting

    ¿Cuáles son algunas aplicaciones prácticas del sistema binario?

    ¿Cuál es el algoritmo correcto para realizar la diferenciación usando un programa de computadora para cualquier función ingresada por el usuario?

    ¿Cómo puedo calcular de manera eficiente el número de intercambios requeridos por los métodos de ordenación lenta como la ordenación por inserción y la ordenación por burbujas para ordenar una matriz determinada?

    ¿Cuál es la operación que tiene la constante más pequeña?

    ¿Cuáles son los diferentes métodos utilizados para representar el árbol binario?

    Cómo encontrar el valor mínimo en una lista vinculada (individual / doblemente) en la menor cantidad de tiempo

    Dada una expresión matemática 2 + 4 * 6 + 8-11, ¿cómo la colocaría entre corchetes de manera que proporcione el valor máximo? ¿Es posible codificar esto?

    ¿Cuál es la diferencia entre Segment Tree y Fenwick Tree en términos de operaciones?

    ¿Hay disponible una implementación de Python del algoritmo de descomposición LDL ('ldl' en Matlab)?

    ¿Existe un método o algoritmo matemático para expresar la suma de un número y un número multiplicado por un radical como la fórmula (a + b) ^ 3?

    ¿Qué es un buen libro sobre estructuras de datos y algoritmos en javascript?

    ¿Qué hace que Google sea poderoso? ¿Son los datos que tienen o el algoritmo eficiente que desarrollan?

    ¿Cuál es la forma más eficiente de ordenar un millón de enteros de 32 bits?

    ¿Cuál es la forma más eficiente para que un programador principiante entienda las tablas hash y los intentos?

    ¿Cuál es el código MATLAB para realizar el algoritmo AntNet?