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); }