Código:
} //arbol binario prefectamente equilibrado
public abstract class CArbolPE
{
// Atributos del árbol binarlo
protected CNodo raiz = null; // raíz del árbol
// Nodo de un árbol binario
private class CNodo
{
// Atributos
private Object datos; // referencia a los datos
private CNodo izquierdo; // raíz del subárbol izquierdo
private CNodo derecho; // raíz del subárbol derecho
// Métodos
public CNodo() {} // constructor
}
// Métodos del árbol binario
public CArbolPE() {} // constructor
public abstract Object leerDatos();///////////////////////////////////////////////abstract////////////////////
public abstract int comparar(Object objl, Object obj2);////////////////////////////abstract///////////////////
public abstract void procesar(Object obj);/////////////////////////////////////////abstract////////////////
public abstract void visitarInorden();/////////////////////////////////abstract////////////////
private CNodo construirArbol(int n)/////////////////////////////////////////////////////////////////
{
// Construye un árbol de n nodos perfectamente equilibrado
CNodo nodo = null;
int ni = 0, nd = 0;
if( n == 0 )
return null;
else
{
ni = n / 2; // nodos del subárbol izquierdo
nd = n - ni - 1; // nodos del subárbol derecho
nodo = new CNodo();
nodo.datos = leerDatos();
nodo.izquierdo = construirArbol(ni);
nodo.derecho = construirArbol(nd);
return nodo;
}
}
public void construirArbolEquilibrado(int n)/////////////////////////////////////////////////////////////
{
raiz = construirArbol(n);
}
private void buscar(Object obj, CNodo r, Object[] datos, int[] pos) ///////////////////////////////////////
{
// Este método buscar permite acceder a un determinado nodo.
// Si los datos especificados por "obj" se localizan en el
// árbol referenciado por "r" a partir de la posición "pos[0]".
// "buscar" devuelve en datos[0] la referencia a esos datos:
// en otro caso, devuelve null.
// Los nodos se consideran numerados (0. 1, 2, ...) según
// el orden en el que son accedidos por el método "inorden".
CNodo actual = r;
if ( actual != null && datos[0] == null )
{
buscar(obj, actual.izquierdo, datos, pos );
if ( comparar( obj, actual.datos )== 0 )
if (pos[0]--== 0)
datos[0] = actual.datos; // nodo encontrado
buscar(obj, actual.derecho, datos, pos);
}
}
public Object buscar(Object obj)// <----- Este es el metodo que siempre me devuelve el mismo objeto
{
return buscar(obj, 0);
}
public Object buscar(Object obj, int posición) /////////////////////////////////////////////////////////
{
Object[] datos = {null};
int[] pos ={posición};
buscar(obj, raiz, datos, pos);
return datos[0];
}
public void inorden( CNodo r, boolean nodoRaiz )////////////////////////////////////////////////////////
{
// El método recursivo inorden visita los nodos del árbol
// utilizando la forma inorden; esto es, primero se visita
// el subárbol izquierdo, después se visita la raíz, y por
// último, el subárbol derecho.
// SI el segundo argumento es true, la visita comienza
// en la raíz independientemente del primer argumento.
CNodo actual = null;
if ( nodoRaiz )
actual = raiz; // partir de la raiz else
else
actual = r; // partir de un nodo cualquiera
if ( actual != null )
{
inorden( actual.izquierdo, false ); // visitar subárbol izq.
// Procesar los datos del nodo visitado
procesar( actual.datos );
inorden( actual.derecho, false ); // visitar subárbol dcho.
}
}
