public int eliminar(String palabra) {
int eliminados = 0;
char c = palabra.charAt(0); // Primer carácter de la palabra
if (izqNodo != null
&& izqNodo.caracter
== c) // Sólo se continúa la eliminación si el primer carácter de la palabra es igual
// al del nodo actual
{
if (palabra.length() > 1) {
eliminados += izqNodo.eliminar(palabra.substring(1));
if (izqNodo.izqNodo == null && eliminados > 0 && izqNodo.elemento == null) {
izqNodo = izqNodo.hermanoDerNodo;
eliminados++;
}
} else {
if (izqNodo.elemento != null) {
izqNodo.elemento = null;
if (izqNodo.izqNodo == null) {
izqNodo = izqNodo.hermanoDerNodo;
eliminados++;
}
}
}
} else if (izqNodo != null
&& izqNodo.caracter < c
&& izqNodo.hermanoDerNodo
!= null) // Buscar si la palabra existe en otro nodo a la derecha y eliminarla
{
// Buscar el nodo en el que se debe realizar la eliminación
NodoPA<T> hermanoIzquierdo = izqNodo;
NodoPA<T> nodo = izqNodo.hermanoDerNodo;
while (nodo != null && nodo.caracter != c) {
hermanoIzquierdo = nodo;
nodo = nodo.hermanoDerNodo;
}
if (nodo != null && palabra.length() > 1) {
eliminados = nodo.eliminar(palabra.substring(1));
if (nodo.izqNodo == null && eliminados > 0 && nodo.elemento == null) {
hermanoIzquierdo.hermanoDerNodo = nodo.hermanoDerNodo;
eliminados++;
}
} else if (nodo != null && nodo.elemento != null) {
nodo.elemento = null;
if (nodo.izqNodo == null) {
hermanoIzquierdo.hermanoDerNodo = nodo.hermanoDerNodo;
eliminados++;
}
}
}
return eliminados;
}
public int insertar(String palabra, T elem) {
// Si la palabra solo tiene 1 carácter y el elemento del hijo izquierdo es igual al elemento a
// insertar, entonces la palabra es repetida
if (palabra.length() == 1
&& izqNodo != null
&& izqNodo.elemento != null
&& izqNodo.elemento.equals(elem)) {}
int elementosInsertados = 0;
char nCaracter = palabra.charAt(0);
if (izqNodo != null
&& izqNodo.caracter
== nCaracter) // Si el carácter del hijo izquierdo es igual al que se quiere insertar
{
if (palabra.length() != 1)
return izqNodo.insertar(
palabra.substring(1),
elem); // El hijo izquierdo es responsable de insertar el nuevo elemento
else izqNodo.elemento = elem; // Se agregó un prefijo de una palabra existente
} else if (izqNodo != null && izqNodo.caracter > nCaracter) {
NodoPA<T> nuevoNodo = null;
if (palabra.length() == 1) {
nuevoNodo = new NodoPA<T>(nCaracter, elem);
} else {
nuevoNodo = new NodoPA<T>(nCaracter); // Nodo solo con el caracter
elementosInsertados += nuevoNodo.insertar(palabra.substring(1), elem);
}
// El carácter a insertar debería ser el nuevo hijo izquierdo del nodo actual
NodoPA<T> temp = izqNodo;
izqNodo = nuevoNodo;
izqNodo.hermanoDerNodo = temp;
elementosInsertados++;
} else if (izqNodo != null
&& izqNodo.hermanoDerNodo
!= null) // Se debe agregar el nodo sobre los hermanos del nodo actual
{
// Se mantiene el anterior por si se deben correr los nodos hermanos
NodoPA<T> iterador = izqNodo.hermanoDerNodo;
NodoPA<T> anterior = izqNodo;
// Ubicar el lugar donde deba ir el nuevo hermano
while (iterador != null && iterador.caracter < nCaracter) {
anterior = iterador;
iterador = iterador.hermanoDerNodo;
}
if (iterador != null
&& iterador.caracter
== nCaracter) // Encontró el nodo que deba agregar el resto de la palabra
{
if (palabra.length() == 1) {
// En caso que la palabra termine y solo deba agregar el elemento a ese nodo
iterador.elemento = elem;
elementosInsertados++;
} else elementosInsertados += iterador.insertar(palabra.substring(1), elem);
} else {
NodoPA<T> nuevoNodo = null;
if (palabra.length() == 1) {
nuevoNodo = new NodoPA<T>(nCaracter, elem);
} else {
nuevoNodo = new NodoPA<T>(nCaracter); // Nodo solo con el caracter
elementosInsertados += nuevoNodo.insertar(palabra.substring(1), elem);
}
// Se debe insertar un nuevo nodo entre dos hermanos
// Debe crear un nuevo nodo y colocarlo
anterior.hermanoDerNodo =
nuevoNodo; // El nuevo hermanoDerecho del anterior es el nuevo nodo
nuevoNodo.hermanoDerNodo =
iterador; // El hermanoDerecho del nuevo nodo es el nodo que se tenia en iterador
elementosInsertados++;
}
} else if (izqNodo != null
&& izqNodo.hermanoDerNodo == null) // No existe un hermano del nodo izquierdo
{
NodoPA<T> nuevoNodo = null;
if (palabra.length() == 1) {
nuevoNodo = new NodoPA<T>(nCaracter, elem);
} else {
nuevoNodo = new NodoPA<T>(nCaracter); // Nodo solo con el caracter
elementosInsertados += nuevoNodo.insertar(palabra.substring(1), elem);
}
izqNodo.hermanoDerNodo = nuevoNodo;
elementosInsertados++;
} else {
NodoPA<T> nuevoNodo = null;
if (palabra.length() == 1) {
nuevoNodo = new NodoPA<T>(nCaracter, elem);
} else {
nuevoNodo = new NodoPA<T>(nCaracter); // Nodo solo con el caracter
elementosInsertados += nuevoNodo.insertar(palabra.substring(1), elem);
}
// Se agrega un nodo como el hijo izquierdo del nodo actual
izqNodo = nuevoNodo;
elementosInsertados++;
}
return elementosInsertados;
}
