private boolean equals(Vertice i, Vertice d) {
// En el caso de que vertices de un nodo y ambos no tengas hijos.
if (i == null && d == null) return true;
// Si los vertices hijos son diferentes.
else if (i != null && d == null || i == null && d != null) return false;
// Compara el elemento y despues a sus hijos por izquierda y
return i.get().equals(d.get())
&& equals(i.izquierdo, d.izquierdo)
&& equals(i.derecho, d.derecho);
}
/**
* Busca recursivamente un elemento, a partir del vértice recibido.
*
* @param vertice el vértice a partir del cuál comenzar la búsqueda. Puede ser <code>null</code>.
* @param elemento el elemento a buscar a partir del vértice.
* @return el vértice que contiene el elemento a buscar, si se encuentra en el árbol; <code>null
* </code> en otro caso.
*/
protected Vertice busca(Vertice vertice, T elemento) {
if (vertice == null) return null;
if (vertice.get().equals(elemento)) return vertice;
Vertice mi = busca(vertice.izquierdo, elemento);
Vertice md = busca(vertice.derecho, elemento);
return mi != null ? mi : md;
}
/**
* Compara el vértice con otro objeto. La comparación es <em>recursiva</em>. Las clases que
* extiendan {@link Vertice} deben sobrecargar el método {@link Vertice#equals}.
*
* @param o el objeto con el cual se comparará el vértice.
* @return <code>true</code> si el objeto es instancia de la clase {@link Vertie}, su elemento
* es igual al elemento de éste vértice, y los descendientes de ambos son recursivamente
* iguales; <code>false</code> en otro caso.
*/
@Override
public boolean equals(Object o) {
if (o == null || raiz == null || getClass() != o.getClass()) return false;
@SuppressWarnings("unchecked")
Vertice vertice = (Vertice) o;
return raiz.get().equals(vertice.get())
&& equals(raiz.izquierdo, vertice.izquierdo)
&& equals(raiz.derecho, vertice.derecho);
}
