/**
* Elimina un nodo que se encuentre en la lista ubicado por su posición.
*
* @param posicion en la cual se encuentra el nodo a eliminar.
*/
public void removerPorPosicion(int posicion) {
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y < que el numero de elementos del la lista.
if (posicion >= 0 && posicion < tamanio) {
// Consulta si el nodo a eliminar es el primero
if (posicion == 0) {
// Elimina el primer nodo apuntando al siguinte.
inicio = inicio.getSiguiente();
}
// En caso que el nodo a eliminar este por el medio
// o sea el ultimo
else {
// Crea una copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta lleger al nodo anterior al eliminar.
for (int i = 0; i < posicion - 1; i++) {
aux = aux.getSiguiente();
}
// Guarda el nodo siguiente al nodo a eliminar.
Nodo siguiente = aux.getSiguiente();
// Elimina la referencia del nodo apuntando al nodo siguiente.
aux.setSiguiente(siguiente.getSiguiente());
}
// Disminuye el contador de tamaño de la lista.
tamanio--;
}
}
/**
* Inserta un nuevo nodo despues de otro, ubicado por el valor que contiene.
*
* @param referencia valor del nodo anterios al nuevo nodo a insertar.
* @param valor del nodo a insertar.
*/
public void insertarPorReferencia(int referencia, int valor) {
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Verifica si la lista contiene elementos
if (!esVacia()) {
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo de referencia.
while (aux.getValor() != referencia) {
aux = aux.getSiguiente();
}
// Crea un respaldo de la continuación de la lista.
Nodo siguiente = aux.getSiguiente();
// Enlaza el nuevo nodo despues del nodo de referencia.
aux.setSiguiente(nuevo);
// Une la continuacion de la lista al nuevo nodo.
nuevo.setSiguiente(siguiente);
// Incrementa el contador de tamaño de la lista.
tamanio++;
}
}
}
/**
* Elimina un nodo que se encuentre en la lista ubicado por un valor de referencia.
*
* @param referencia valor del nodo que se desea eliminar.
*/
public void removerPorReferencia(int referencia) {
// Consulta si el valor de referencia existe en la lista.
if (buscar(referencia)) {
// Consulta si el nodo a eliminar es el pirmero
if (inicio.getValor() == referencia) {
// El primer nodo apunta al siguiente.
inicio = inicio.getSiguiente();
} else {
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo anterior
// al de referencia.
while (aux.getSiguiente().getValor() != referencia) {
aux = aux.getSiguiente();
}
// Guarda el nodo siguiente del nodo a eliminar.
Nodo siguiente = aux.getSiguiente().getSiguiente();
// Enlaza el nodo anterior al de eliminar con el
// sguiente despues de el.
aux.setSiguiente(siguiente);
}
// Disminuye el contador de tamaño de la lista.
tamanio--;
}
}
public int tamano() {
int resultado = 0;
Nodo<T> actual = raiz;
while (actual != null) {
actual = actual.getSiguiente();
resultado++;
}
return resultado;
}
public int contar() {
Nodo mNodo = Inicio;
int contador = 0;
while (mNodo != null) {
mNodo = mNodo.getSiguiente();
contador++;
}
return contador;
}
/**
* Inserta un nuevo nodo despues en una posición determinada.
*
* @param posicion en la cual se va a insertar el nuevo nodo.
* @param valor valor del nuevo nodo de la lista.
*/
public void insrtarPorPosicion(int posicion, int valor) {
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y <= que el numero de elementos del la lista.
if (posicion >= 0 && posicion <= tamanio) {
Nodo nuevo = new Nodo();
nuevo.setValor(valor);
// Consulta si el nuevo nodo a ingresar va al inicio de la lista.
if (posicion == 0) {
// Inserta el nuevo nodo al inicio de la lista.
nuevo.setSiguiente(inicio);
inicio = nuevo;
} else {
// Si el nodo a inserta va al final de la lista.
if (posicion == tamanio) {
Nodo aux = inicio;
// Recorre la lista hasta llegar al ultimo nodo.
while (aux.getSiguiente() != null) {
aux = aux.getSiguiente();
}
// Inserta el nuevo nodo despues de del ultimo.
aux.setSiguiente(nuevo);
} else {
// Si el nodo a insertar va en el medio de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo anterior
// a la posicion en la cual se insertara el nuevo nodo.
for (int i = 0; i < (posicion - 1); i++) {
aux = aux.getSiguiente();
}
// Guarda el nodo siguiente al nodo en la posición
// en la cual va a insertar el nevo nodo.
Nodo siguiente = aux.getSiguiente();
// Inserta el nuevo nodo en la posición indicada.
aux.setSiguiente(nuevo);
// Une el nuevo nodo con el resto de la lista.
nuevo.setSiguiente(siguiente);
}
}
// Incrementa el contador de tamaño de la lista.
tamanio++;
}
}
public boolean eliminar(String cadena) {
boolean borrado = false;
Nodo mNodo;
Nodo antNodo;
// Buscando el nodo con el número
mNodo = this.Inicio;
while ((mNodo != null) && (!mNodo.getDato().equals(cadena))) {
mNodo = mNodo.getSiguiente();
}
if (mNodo != null) {
if (mNodo == this.Inicio) {
this.Inicio = this.Inicio.getSiguiente();
} else if (mNodo == this.Fin) {
// Llegar al anterior al fin
antNodo = this.Inicio;
while (antNodo.getSiguiente() != mNodo) {
antNodo = antNodo.getSiguiente();
}
this.Fin = antNodo;
this.Fin.setSiguiente(null);
} else {
// Llengar al anterior al buscado
antNodo = this.Inicio;
while (antNodo.getSiguiente() != mNodo) {
antNodo = antNodo.getSiguiente();
}
antNodo.setSiguiente(mNodo.getSiguiente());
}
borrado = true;
}
return borrado;
}
/**
* Actualiza el valor de un nodo que se encuentre en la lista ubicado por un valor de referencia.
*
* @param referencia valor del nodo el cual se desea actualizar.
* @param valor nuevo valor para el nodo.
*/
public void editarPorReferencia(int referencia, int valor) {
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo de referencia.
while (aux.getValor() != referencia) {
aux = aux.getSiguiente();
}
// Actualizamos el valor del nodo
aux.setValor(valor);
}
}
/**
* Agrega un nuevo nodo al final de la lista.
*
* @param valor a agregar.
*/
public void agregarAlFinal(int valor) {
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Consulta si la lista esta vacia.
if (esVacia()) {
// Inicializa la lista agregando como inicio al nuevo nodo.
inicio = nuevo;
// Caso contrario recorre la lista hasta llegar al ultimo nodo
// y agrega el nuevo.
} else {
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al ultimo nodo.
while (aux.getSiguiente() != null) {
aux = aux.getSiguiente();
}
// Agrega el nuevo nodo al final de la lista.
aux.setSiguiente(nuevo);
}
// Incrementa el contador de tamaño de la lista
tamanio++;
}
public T get(int i) {
if (raiz == null) throw new IndexOutOfBoundsException();
if (i == 0) return raiz.getContenido();
int resultado = 0;
Nodo<T> actual = raiz;
while (actual != null && resultado < i) {
actual = actual.getSiguiente();
resultado++;
}
if (resultado == i) return actual.getContenido();
logger.error("Se busco la posicion " + i + " pero antes la cadena es nula");
throw new IndexOutOfBoundsException();
}
public int buscar(String cadena) {
Nodo mNodo;
int posicion = 0;
// Buscando el nodo con el número
if (this.Inicio != null) {
mNodo = this.Inicio;
while ((mNodo != null) && (!mNodo.getDato().equals(cadena))) {
mNodo = mNodo.getSiguiente();
posicion++;
}
} else {
posicion = -1;
}
return posicion;
}
public boolean modificar(String cadenaanterior, String cadenanueva) {
boolean modificado = false;
Nodo mNodo;
// Buscando el nodo con el número
mNodo = this.Inicio;
while ((mNodo != null) && (!mNodo.getDato().equals(cadenaanterior))) {
mNodo = mNodo.getSiguiente();
}
if (mNodo != null) {
mNodo.setDato(cadenanueva);
modificado = true;
}
return modificado;
}
/** Mustra en pantalla los elementos de la lista. */
public void listar() {
// Verifica si la lista contiene elementoa.
if (!esVacia()) {
// Crea una copia de la lista.
Nodo aux = inicio;
// Posicion de los elementos de la lista.
int i = 0;
// Recorre la lista hasta el final.
while (aux != null) {
// Imprime en pantalla el valor del nodo.
System.out.print(i + ".[ " + aux.getValor() + " ]" + " -> ");
// Avanza al siguiente nodo.
aux = aux.getSiguiente();
// Incrementa el contador de la posión.
i++;
}
}
}
/**
* Busca si existe un valor en la lista.
*
* @param referencia valor a buscar.
* @return true si existe el valor en la lista.
*/
public boolean buscar(int referencia) {
// Crea una copia de la lista.
Nodo aux = inicio;
// Bandera para indicar si el valor existe.
boolean encontrado = false;
// Recorre la lista hasta encontrar el elemento o hasta
// llegar al final de la lista.
while (aux != null && encontrado != true) {
// Consulta si el valor del nodo es igual al de referencia.
if (referencia == aux.getValor()) {
// Canbia el valor de la bandera.
encontrado = true;
} else {
// Avansa al siguiente. nodo.
aux = aux.getSiguiente();
}
}
// Retorna el resultado de la bandera.
return encontrado;
}
/**
* Consulta la posición de un elemento en la lista
*
* @param referencia valor del nodo el cual se desea saber la posición.
* @return un valor entero entre [0,n] que indica la posición del nodo.
* @throws Exception
*/
public int getPosicion(int referencia) throws Exception {
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
// Crea una copia de la lista.
Nodo aux = inicio;
// COntado para almacenar la posición del nodo.
int cont = 0;
// Recoore la lista hasta llegar al nodo de referencia.
while (referencia != aux.getValor()) {
// Incrementa el contador.
cont++;
// Avansa al siguiente. nodo.
aux = aux.getSiguiente();
}
// Retorna el valor del contador.
return cont;
// Crea una excepción de Valor inexistente en la lista.
} else {
throw new Exception("Valor inexistente en la lista.");
}
}
/**
* Actualiza el valor de un nodo que se encuentre en la lista ubicado por su posición.
*
* @param posicion en la cual se encuentra el nodo a actualizar.
* @param valor nuevo valor para el nodo.
*/
public void editarPorPosicion(int posicion, int valor) {
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y < que el numero de elementos del la lista.
if (posicion >= 0 && posicion < tamanio) {
// Consulta si el nodo a eliminar es el primero.
if (posicion == 0) {
// Alctualiza el valor delprimer nodo.
inicio.setValor(valor);
} else {
// En caso que el nodo a eliminar este por el medio
// o sea el ultimo
Nodo aux = inicio;
// Recorre la lista hasta lleger al nodo anterior al eliminar.
for (int i = 0; i < posicion; i++) {
aux = aux.getSiguiente();
}
// Alctualiza el valor del nodo.
aux.setValor(valor);
}
}
}
/**
* Obtiene el valor de un nodo en una determinada posición.
*
* @param posicion del nodo que se desea obtener su valor.
* @return un numero entero entre [0,n-1] n = numero de nodos de la lista.
* @throws Exception
*/
public int getValor(int posicion) throws Exception {
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y < que el numero de elementos del la lista.
if (posicion >= 0 && posicion < tamanio) {
// Consulta si la posicion es el inicio de la lista.
if (posicion == 0) {
// Retorna el valor del inicio de la lista.
return inicio.getValor();
} else {
// Crea una copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta la posición ingresada.
for (int i = 0; i < posicion; i++) {
aux = aux.getSiguiente();
}
// Retorna el valor del nodo.
return aux.getValor();
}
// Crea una excepción de Posicion inexistente en la lista.
} else {
throw new Exception("Posicion inexistente en la lista.");
}
}
@Override
public M next() {
M respuesta = actual.getContenido();
actual = actual.getSiguiente();
return respuesta;
}
