public void inorden(IteradorSimple<T> resultado) {
if (izqNodo != null) {
izqNodo.inorden(resultado);
if (elemento != null) {
try {
resultado.agregar(elemento);
} catch (IteradorException e) {
}
}
NodoPA<T> aux = izqNodo.hermanoDerNodo;
while (aux != null) {
aux.inorden(resultado);
aux = aux.hermanoDerNodo;
}
} else {
if (elemento != null) {
try {
resultado.agregar(elemento);
} catch (IteradorException e) {
}
}
}
}
public int darAltura() {
int altura = (izqNodo == null) ? 1 : izqNodo.darAltura() + 1;
int aux = (hermanoDerNodo == null) ? 0 : hermanoDerNodo.darAltura();
if (aux > altura) {
altura = aux;
}
return altura;
}
private void darElementosPA(Lista<T> lista) {
if (elemento != null) {
lista.agregar(elemento);
}
if (izqNodo != null) {
izqNodo.darElementosPA(lista);
NodoPA<T> nodo = izqNodo.hermanoDerNodo;
while (nodo != null) {
nodo.darElementosPA(lista);
nodo = nodo.hermanoDerNodo;
}
}
}
public Lista<T> buscarPorPrefijo(String prefijo) {
Lista<T> lista = new Lista<T>();
raiz.buscarPorPrefijo(prefijo, lista);
return lista;
}
public T eliminar(String palabra) {
T elemento = buscar(palabra);
int eliminados = elemento != null ? raiz.eliminar(palabra) : 0;
peso -= eliminados;
return elemento;
}
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 void buscarPorPrefijo(String prefijo, Lista<T> lista) {
NodoPA<T> aux = this.izqNodo;
// Se ubica el nodo a partir del cual se deben recolectar los elementos
while (aux != null && prefijo.length() != 0) {
char nCaracter = prefijo.charAt(0);
if (aux.caracter == nCaracter) {
prefijo = prefijo.substring(1);
if (prefijo.length() != 0) {
aux = aux.izqNodo;
}
} else if (aux.hermanoDerNodo != null) {
while (aux != null && aux.caracter != nCaracter) {
aux = aux.hermanoDerNodo;
}
} else aux = null;
}
if (aux != null) {
aux.darElementosPA(lista);
}
}
public int darAltura() {
return (raiz != null) ? raiz.darAltura() : 0;
}
public IteradorSimple<T> inorden() {
IteradorSimple<T> resultado = new IteradorSimple<T>(peso);
raiz.inorden(resultado);
return resultado;
}
public T buscar(String palabra) {
return raiz.buscar(palabra);
}
public void insertar(T elemento) {
String palabra = elemento.toString();
peso += raiz.insertar(palabra, elemento);
}
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;
}
