También utiliza el siguiente código para insertar datos en el árbol de búsqueda binario.
y también visita: –
geeksforgeeks.org
- ¿Es posible encontrar la distancia del vértice más alejada del vértice inicial mediante la solución iterativa de DFS para un árbol (NO un gráfico genérico)?
- ¿Qué tiene de malo este programa?
- ¿Cuáles son las ventajas y desventajas de comparar la búsqueda de árboles de Monte Carlo y la programación dinámica aproximada?
- Cómo escribir un algoritmo para la suma de n factoriales. es decir, 1! +2! +3! +… (N-1) + n
- Optimización matemática: ¿Cuáles son las aplicaciones para el problema del vendedor ambulante?
Árbol de búsqueda binaria
tutorialspoint.com
clase pública BinaryTree {
raíz del nodo público;
public BinaryTree (raíz de nodo) {
this.root = root;
}
Nodo público findSuccessor (nodo de nodo) {
nodo = searchForNode (nodo, raíz);
Nodo temp = nulo;
if (node.getRight ()! = null) {
nodo = nodo.getRight ();
while (nodo! = nulo) {
temp = nodo;
nodo = nodo.getRight ();
}
}
temperatura de retorno;
}
public void postOrder (nodo de nodo) {
if (nodo == nulo) {
regreso ;
}
postOrder (node.getLeft ());
postOrder (node.getRight ());
System.out.println (node.getData ());
}
public void inOrder (nodo de nodo) {
if (nodo == nulo) {
regreso ;
}
inOrder (node.getLeft ());
System.out.println (node.getData ());
inOrder (node.getRight ());
}
public boolean find (Node searchNode) {
búsqueda de retorno (searchNode, root);
}
Nodo público max () {
devuelve findMax (root);
}
Nodo privado findMax (nodo de nodo) {
if (node.getRight () == null) {
nodo de retorno;
}
devuelve findMax (node.getRight ());
}
Nodo público min () {
volver findMin (root);
}
Nodo privado findMin (nodo de nodo) {
if (node.getLeft () == null) {
nodo de retorno;
}
devuelva findMin (node.getLeft ());
}
búsqueda booleana privada (nodo de nodo, raíz de nodo) {
if (raíz == nulo)
falso retorno;
if (node.getData () == root.getData ()) {
volver verdadero;
} else if (node.getData () <root.getData ()) {
búsqueda de retorno (nodo, root.getLeft ());
} más {
búsqueda de retorno (nodo, root.getRight ());
}
}
Nodo privado searchForNode (nodo de nodo, raíz de nodo) {
if (raíz == nulo)
volver nulo;
if (node.getData () == root.getData ()) {
volver root;
} else if (node.getData () <root.getData ()) {
return searchForNode (nodo, root.getLeft ());
} más {
return searchForNode (nodo, root.getRight ());
}
}
inserción vacía pública (nodo de nodo) {
insertNewNode (raíz, nodo);
}
private void insertNewNode (Nodo nodo, Nodo nuevoNodo) {
if (nodo! = nulo) {
if (node.getData ()> newNode.getData ()) {
if (node.getLeft () == null) {
node.setLeft (newNode);
} más {
insertNewNode (node.getLeft (), newNode);
}
} más {
if (node.getRight () == null) {
node.setRight (newNode);
} más {
insertNewNode (node.getRight (), newNode);
}
}
}
}
}
Nodo de clase {
datos int privados;
Nodo privado a la izquierda;
derecho de nodo privado;
Nodo público (datos int) {
this.data = datos;
}
public int getData () {
devolver datos;
}
setData public void (datos int) {
this.data = datos;
}
Nodo público getLeft () {
volver a la izquierda;
}
public void setLeft (Nodo a la izquierda) {
this.left = left;
}
Nodo público getRight () {
volver a la derecha;
}
public void setRight (Nodo derecho) {
this.right = right;
}
}
Recorrido de clase pública {
public static void main (String [] args) {
BinaryTree binaryTree = nuevo BinaryTree (nuevo nodo (10));
binaryTree.insert (nuevo Nodo (8));
binaryTree.insert (nuevo Nodo (15));
binaryTree.insert (nuevo Nodo (2));
//binaryTree.insert(new Node (9));
//binaryTree.insert(new Node (13));
binaryTree.insert (nuevo Nodo (18));
/*binaryTree.preOrder(binaryTree.root);
System.out.println (“———-“);
binaryTree.postOrder (binaryTree.root);
System.out.println (“————–”);
binaryTree.inOrder (binaryTree.root); * /
binaryTree.inOrder (binaryTree.root);
//binaryTree.delete(new Node (15));
System.out.println (“—————————–”);
binaryTree.inOrder (binaryTree.root);
}
}
