Tabla de contenido
Búsqueda de nodos de árbol de búsqueda binaria
Código de archivo src/runoob/binary/BinarySearchTreeSearch.java:
Búsqueda de nodos de árbol de búsqueda binaria
El árbol de búsqueda binario no tiene subíndice, por lo que para la operación de búsqueda del árbol de búsqueda binario, aquí se define un método de contención para determinar si el árbol de búsqueda binario contiene un elemento y devolver una variable booleana. Esta operación de búsqueda también es un proceso recursivo. específicamente El código se implementa de la siguiente manera:
...
// Comprobar si el árbol de búsqueda binario enraizado en el nodo contiene un nodo cuyo valor clave es clave, utilizando un algoritmo recursivo
private boolean contiene(Nodo nodo, Clave clave){ if( nodo == null ) return false; if( key.compareTo(node.key) == 0 ) devuelve verdadero; de lo contrario, si (key.compareTo(node.key) < 0 ) devuelve contiene( node.left, clave); else // clave > nodo->clave devuelve contiene (nodo.derecha, clave); } ...
El siguiente ejemplo encuentra 43 elementos en un árbol de búsqueda binario.
(1) El elemento 43 es más grande que el nodo raíz 42 y la comparación debe continuar en el nodo secundario derecho.
(2) El elemento 43 es menor que 59, por lo que la comparación debe continuar en el nodo secundario izquierdo.
(3) El elemento 43 es menor que 51, por lo que la comparación debe continuar en el nodo secundario izquierdo.
(4) Encuentre el nodo secundario izquierdo 43 de 51, que es exactamente igual a la suma, y finalice.
Si necesita encontrar el valor correspondiente a la clave, el código es el siguiente:
...
// Encuentra el valor correspondiente a la clave en el árbol de búsqueda binaria con el nodo como raíz, algoritmo recursivo
// Si el valor no existe, devuelve NULL
búsqueda de valor privado (Nodo nodo, Clave clave){ if( nodo == nulo) devuelve nulo; si (key.compareTo(node.key) == 0) devuelve nodo.valor; de lo contrario, si (key.compareTo(node.key) <0) devuelve búsqueda (node.left, clave); else // clave > nodo->clave devolver búsqueda( nodo.derecha, clave ); } ...
Código de ejemplo de Java
Descarga del paquete de código fuente: Descargar 
https://www.runoob.com/wp-content/uploads/2020/09/runoob-algorithm-BinarySearchTreeSearch.zip
Código de archivo src/runoob/binary/BinarySearchTreeSearch.java:
paquete runoob.binary;
/**
* búsqueda de árbol de búsqueda binaria
*/
public class BinarySearchTreeSearch<Key extends Comparable<Key>, Value> { // Los nodos en el árbol son clases privadas y el mundo exterior no necesita conocer el detalles de los nodos del árbol de búsqueda binaria Implementar clase privada Nodo { clave clave privada; valor de valor privado; nodo privado izquierda, derecha; nodo público (clave clave, valor valor) { this.key = clave; this.value = valor; izquierda = right = null; } } // Nodo raíz private Node root; // El número de nodos en el árbol private int count; // Constructor, construye un árbol de búsqueda binario vacío de forma predeterminada public BinarySearchTreeSearch() {
root = null;
count = 0;
}
// devuelve el número de nodos en el árbol de búsqueda binario
public int size() { return count; } // devuelve si el árbol de búsqueda binario está vacío public boolean isEmpty() { return count = = 0; } // Inserta un nuevo par de datos (clave, valor) en el árbol de búsqueda binario public void insert(Clave clave, Valor valor){ root = insert(raíz, clave, valor); } // Comprobar si el binario el árbol de búsqueda es La clave clave existe public boolean contiene(Clave clave){ return contiene(raíz, clave); } // Busca el valor correspondiente a la clave clave en el árbol de búsqueda binario. Si este valor no existe, se devuelve nulo public Value search(Key key){ return search(root, key);
}
//************************
//* Función auxiliar para el árbol de búsqueda binaria
//************** ** ****
// Inserte un nodo (clave, valor) en el árbol de búsqueda binaria con raíz en el nodo y utilice un algoritmo recursivo
// para devolver la raíz del árbol de búsqueda binaria después de insertar el nuevo nodo
private Node insert( Nodo nodo, clave clave, valor valor){ if( nodo == null ){ recuento ++; devolver nuevo nodo(clave, valor); } if( key.compareTo(node.key) == 0 ) node.value = valor; else if( clave.compareTo(nodo.clave) < 0 ) nodo.izquierda = insertar( nodo.izquierda , clave, valor); else // clave > nodo->clave nodo.derecha = insertar( nodo.derecha, clave, valor); nodo de retorno;
}
// Comprobar si el árbol de búsqueda binaria con el nodo como raíz contiene un nodo con el valor clave, utilizando el algoritmo recursivo
private boolean contiene(Nodo nodo, Clave clave){ if( nodo == null ) return false; if( clave . compareTo(node.key) == 0 ) devuelve verdadero; de lo contrario, si (key.compareTo(node.key) < 0 ) devuelve contiene( node.left, clave); else // clave > nodo->clave devuelve contiene( nodo .derecho, clave); } // Encuentra el valor correspondiente a la clave en el árbol de búsqueda binaria con el nodo como raíz, algoritmo recursivo // Si el valor no existe, devuelve NULL búsqueda de valor privado (nodo de nodo, clave clave){ si (nodo == nulo) devuelve nulo; si (key.compareTo(nodo.key) == 0)
devolver nodo.valor;
de lo contrario si (key.compareTo (nodo.key) <0)
devolver búsqueda (node.left, clave);
else // clave > nodo->clave
return search( nodo.derecha, clave );
}
}