Duda con Metodo recursivo

[calichecal]

hola a todos,e estado haciendo una clase generica para hacer arboles binarios perfectamente equilibrados, pero no me quiere funcionar bien el metodo que se encarga de buscar un nodo, siempre me devuelve un mismo objeto, e verficado varias veces pero no encuentro el error, agradesco por su tiempo, al que analize la clase, que la voy a dejar a continuacion:

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

}