Problema al borrar en árbol Set casero

[detective_jd]

Hola FuzzyLog por responder, hice lo que me dijiste y no funcionó:

Código Java:

private void probando_borrado(Object[]arreglo, Object[]criterio) throws Exception{
            set.clear();
            for (Object obj : arreglo) {
                set.add(obj.toString());
            }            
            MyTreeSet<String>aux = set;
            for(Object c : criterio){
                if(c == null){
                    aux.remove(null);
                    this.comprobar_que(!set.contains(null));
                } else {
                    aux.remove(c.toString());
                    this.comprobar_que(!set.contains(c.toString()));
                }                        
            }
        }
 

Depuré el código y aquí esta el resultado:

El órden después de insertar los string al set:

"Deborah" < - > "Denisse" < - > "Franco" < - > "Manuela" < - > "Miguel" < - > "Tommy"

Cuando quiero borrar a "Franco"

línea 343 : decrementa el tamaño a 1 menos
línea 351 : y tiene la entrada "Manuela"
línea 359 : x es nulo
línea 361 : el pariente de x pasa a ser Miguel
linea 367 : como el pariente de x no es nulo, entra en la contradicción (else)
línea 377 : como y es igual al izquierdo del pariente de y, entra en la condición (if)
línea 378 : el izquierdo del pariente de y, pasa a ser nulo
línea 389 : al ser distintos (y) y (p), entra en la condición
línea 390 : p toma el valor de y
línea 395 : como el color de y no es negro, no entra en el if.

El problema parece ser el órden de los datos a eliminar y ahí es dónde no me doy cuenta que arreglar si el deleteEntry (que parece lo más evidente a arreglar) o que.

Pondré el código del deleteEntry de MyTreeMap.java, ya que puede que no mires el repositorio de github, pero otro lado por dónde mirarlo no se me ocurre:

Código Java:

private void deleteEntry(Entry<K,V> p) {
        // Decrementa la cantidad de elementos en el árbol.
        size--;
        // Creamos una nueva entrada vacía.
        Entry<K,V> tmp = new Entry();
        /*
            Creamos una entrada llamada y y mediante un operador ternario si 
            la izquierda o derecha de p es nula que y tenga el valor de p de 
            lo contrario de obtenga al siguiente de p.
        */
        Entry<K,V> y = (leftOf(p) == null || rightOf(p) == null) ? p : higherEntry(p.getKey());
        /*
            Luego creo otra entrada llamada x y mediante operador ternario
            si la izquierda de y no es nula, x tendrá como valor la izquierda
            de y de lo contrario otro operador ternario dentro del primero que
            si la derecha de y no es nula que x obtenga como valor la derecha
            de y  de lo contrario obtendrá la entrada vacía.
        */
        Entry<K,V> x = (leftOf(y) != null) ? leftOf(y) : (rightOf(y) != null ? rightOf(y) : tmp);        
        // Al pariente de x se le asignará como valor el pariente de y
        x.parent = parentOf(y);
        /*
            Sí el pariente de y es nulo, la raíz del árbol se le asignará como
            valor mediante operador ternario que si x es una entrada vacía
            la raíz será nula de lo contrario x será el valor de la raíz
        */
        if (parentOf(y) == null) {
            root = (x == tmp ? null : x);
        } else {
            /*
                Ahora si el pariente de y no es nulo, entramos en otra
                condición que si y es igual al izquierdo del pariente de y
                el izquierdo del pariente de y tendrá como valor mediente
                operador ternario si x es una entrada vacía será nulo sino
                su valor será x
            */
            if (y == leftOf(parentOf(y))) {
                y.parent.left = (x == tmp) ? null : x;
            } else {
                /*
                    De lo contrario el derecho del pariente de y tendrá como
                    valor por operador ternario si x es una entrada vacía
                    su valor será nulo sino será x
                */
                y.parent.right = (x == tmp) ? null : x; 
            }
        }
        // Si y es distinto de p, a p se le asignará como valor y
        if (y != p){
            p = y;
        }
        /*  Y si el color de y es negro, el árbol será balanceado para 
            actualizarse luego de la eliminación
        */
        if (colorOf(y) == BLACK) {
            fixDown(x);
        }
    }
 

Espero sus respuestas y saludos.