public T eliminar(int pos) {
T valor = null;
if ((pos >= numElems) || pos < 0) {
throw new IndiceFueraDeRangoException(pos);
} else if (pos == 0) {
if (primero.equals(ultimo)) {
ultimo = null;
}
valor = primero.darElemento();
primero = primero.desconectarPrimero();
numElems--;
return valor;
} else {
NodoLista<T> p = primero.darSiguiente();
for (int cont = 1; cont < pos; cont++) {
p = p.darSiguiente();
}
if (p.equals(ultimo)) {
ultimo = p.darAnterior();
}
valor = p.darElemento();
p.desconectarNodo();
numElems--;
return valor;
}
}
public NodoLista<T> desconectarPrimero() {
NodoLista<T> p = sigNodo;
sigNodo = null;
if (p != null) {
p.antNodo = null;
}
return p;
}
public T buscar(T modelo) {
for (NodoLista<T> p = primero; p != null; p = p.darSiguiente()) {
if (p.darElemento().equals(modelo)) {
return p.darElemento();
}
}
return null;
}
public void desconectarNodo() {
NodoLista<T> ant = antNodo;
NodoLista<T> sig = sigNodo;
antNodo = null;
sigNodo = null;
ant.sigNodo = sig;
if (sig != null) {
sig.antNodo = ant;
}
}
public Object[] darArreglo() {
Object[] arreglo = new Object[darLongitud()];
NodoLista<T> actual = primero;
int i = 0;
while (actual != null) {
arreglo[i] = actual.darElemento();
i++;
actual = actual.darSiguiente();
}
return arreglo;
}
public T buscar(T elemento, Comparator<T> c) {
NodoLista<T> actual = primero;
while (actual != null) {
if (c.compare(elemento, actual.darElemento()) == 0) {
return actual.darElemento();
} else {
actual = actual.darSiguiente();
}
}
return null;
}
/**
* Retorna el primer elemento de la lista<br>
* Elimina el elemento de la lista.
*
* @return
*/
public T darPrimero() {
if (primero != null) {
T respuesta = primero.darElemento();
primero = primero.darSiguiente();
if (primero != null) {
primero.cambiarAnterior(null);
}
longitud--;
return respuesta;
}
return null;
}
public T dar(int pos) {
if (pos >= numElems || pos < 0) {
throw new IndiceFueraDeRangoException(pos);
} else {
NodoLista<T> aux = primero;
for (int cont = 0; cont < pos; cont++) {
aux = aux.darSiguiente();
}
return aux.darElemento();
}
}
public Iterador<T> darIterador() {
IteradorSimple<T> respuesta = new IteradorSimple<T>(numElems);
NodoLista<T> iterador = primero;
while (iterador != null) {
try {
respuesta.agregar(iterador.darElemento());
iterador = iterador.darSiguiente();
} catch (IteradorException e) {
}
}
return respuesta;
}
public void insertar(T elemento, int pos) {
NodoLista<T> nodo = new NodoLista<T>(elemento);
if ((pos >= numElems) || pos < 0) {
throw new IndiceFueraDeRangoException(pos);
} else {
NodoLista<T> aux = primero;
for (int cont = 0; cont < pos - 1; cont++) {
aux = aux.darSiguiente();
}
aux.insertarDespues(nodo);
numElems++;
}
}
/**
* Método que busca un elemento en la Lista
* @param e - objeto a ser buscado en la Lista
* @return el elemento buscado en caso de existir, o null en su defecto
*/
public T buscar(T e){
boolean a = false;
NodoLista temp = nodo;
while(temp!=null){
if(temp.darElemento==e){
return temp;
a=true;
}
temp=temp.siguiente();
}
if(a==false){
return null;
}
}
public void eliminarNodo(NodoLista<T> nodo) throws NoExisteException {
if (buscar(nodo.darElemento()) != null) {
throw new NoExisteException("El nodo especificado no pertenece a la lista");
}
if (primero == nodo) {
primero = nodo.desconectarPrimero();
if (ultimo == nodo) {
ultimo = null;
}
} else {
if (ultimo == nodo) {
ultimo = nodo.darAnterior();
}
nodo.desconectarNodo();
}
}
public void insertarCola(T elemento) {
NodoLista<T> nodo = new NodoLista<T>(elemento);
if (primero == null) {
primero = nodo;
ultimo = nodo;
} else {
ultimo.insertarDespues(nodo);
ultimo = nodo;
}
numElems++;
}
public void insertarCabeza(T elemento) {
NodoLista<T> nodo = new NodoLista<T>(elemento);
if (primero == null) {
primero = nodo;
ultimo = nodo;
} else {
primero.insertarAntes(nodo);
primero = nodo;
}
numElems++;
}
public T eliminarUltimo() {
if (ultimo == null) {
return null;
} else {
try {
return eliminar(ultimo.darElemento());
} catch (NoExisteException e) {
return null;
}
}
}
public T eliminarPrimero() {
//
// Si no tiene
if (primero == null) {
return null;
} else {
//
// Elimina el primer elemento
try {
return eliminar(primero.darElemento());
} catch (NoExisteException e) {
return null;
}
}
}
public String toString() {
String resp = "ida: [" + numElems + "]:";
for (NodoLista<T> p = primero; p != null; p = p.darSiguiente()) {
resp += p.darElemento().toString() + "<->";
}
resp += "\r\nvuelta:[" + numElems + "]:";
for (NodoLista<T> p = ultimo; p != null; p = p.darAnterior()) {
resp += p.darElemento().toString() + "<->";
}
return resp;
}
public T eliminar(T elemento) {
NodoLista<T> actual = primero;
if (elemento == null || longitud == 0) {
return null;
} else if (elemento.compareTo(actual.darElemento()) == 0) {
primero = actual.darSiguiente();
if (primero != null) {
primero.cambiarAnterior(null);
}
longitud--;
return elemento;
} else {
actual = actual.darSiguiente();
while (actual != null) {
if (elemento.compareTo(actual.darElemento()) == 0) {
NodoLista<T> anterior = actual.darAnterior();
NodoLista<T> siguiente = actual.darSiguiente();
anterior.cambiarSiguiente(siguiente);
if (siguiente != null) {
siguiente.cambiarAnterior(anterior);
}
longitud--;
return elemento;
} else {
actual = actual.darSiguiente();
}
}
}
return null;
}
public void insertarAntes(NodoLista<T> nodo) {
nodo.sigNodo = this;
nodo.antNodo = antNodo;
if (antNodo != null) antNodo.sigNodo = nodo;
antNodo = nodo;
}
public void insertarDespues(NodoLista<T> nodo) {
nodo.sigNodo = sigNodo;
nodo.antNodo = this;
if (sigNodo != null) sigNodo.antNodo = nodo;
sigNodo = nodo;
}
public T eliminar(T elemento) throws NoExisteException {
T valor = null;
if (primero == null) {
throw new NoExisteException("Elemento no existe");
} else if (primero.darElemento().equals(elemento)) {
if (primero.equals(ultimo)) {
ultimo = null;
}
valor = primero.darElemento();
primero = primero.desconectarPrimero();
numElems--;
return valor;
} else {
for (NodoLista<T> p = primero.darSiguiente(); p != null; p = p.darSiguiente()) {
if (p.darElemento().equals(elemento)) {
if (p.equals(ultimo)) {
ultimo = p.darAnterior();
}
valor = p.darElemento();
p.desconectarNodo();
numElems--;
return valor;
}
}
throw new NoExisteException("Elemento no existe");
}
}
