Alguien que me pueda ayudar a realizar el metodo eliminar de una lista enlazada, en este caso que elimine el primer String que se ingreso y no el ultimo.
package listaReproduccion;
import java.util.Scanner;
public class listaReproduccion {
static Scanner read = new Scanner(System.in);
static String nombre;
static NodoCanciones primero = null;
NodoCanciones ultimo = null;
public void insertar() {
System.out.print("Nombre de la cancion: ");
nombre = read.next();
System.out.println(nombre);
NodoCanciones nuevo = new NodoCanciones(nombre);
nuevo.sig = null;
if (primero == null && ultimo == null) {
primero = nuevo;
ultimo = nuevo;
} else {
ultimo.sig = nuevo;
ultimo = nuevo;
}
}
public void imprimir(){
NodoCanciones temp = primero;
System.out.println("CANCIONES");
while (temp != null) {
System.out.print(temp.nombre);
temp = temp.sig;
System.out.println();
}
}
public NodoCanciones eliminar() {
}
public static void main(String args[]) {
int menu, dato;
listaReproduccion lista = new listaReproduccion();
System.out.println("LISTA DE NUMEROS ENTEROS");
do {
System.out.println("MENU \n 1.- Agregar una cancion \n 2.- Imprimir Lista de Reproduccion \n "
+ "3.- Eliminar cancion \n 4.- Salir");
menu = read.nextInt();
switch (menu) {
case 1:
lista.insertar();
break;
case 2:
lista.imprimir();
break;
case 3:
break;
case 4:
System.exit(0);
default:
System.out.println("Seleccione una opcion: ");
}
} while (menu != 4 || menu <= 0);
}
}
Lo Idela es añadir una función que reclame eliminar el enésimo ítem. También es válido que haya sendas funciones para eliminar el último y/o el primero.
Considera una lista (doblemente) enlazada como los eslabones de una cadena. eliminar un eslabón supone disgregarlo de sus ataduras (anterior y posterior), pero admeás para no fastidiar la cadena y que queden suelta en dos partes, deben unirse sus extremos nuevamente...
Nótese que anes de soltar el eslabón se usa su 'conocimiento', para conectar sus extremos entre si.
Las operaciones pués son:
funcion Eliminar(entero index)
nodo = Buscarnodo(index) // 0 si es el primero, -1 si es el último
//Atar el previo con el siguiente (si no es el primero)
Si (index <> 0)
// y si no es también el último (esto es si solo hay 1 quedaría vacía)
Si (cantidad >1)
nodo.anterior.siguiente = nodo.siguiente
fin si
sino
primero = nodo.siguiente
fin si
// Truncamos el índice si se pide eliminar el último indicando su ínndice absoluto
// Puedes decidir como opcional indicar error si se reclama eliminar un índice no existente
// (mayor que la cantidad existente), aunque también puede aceptarse como indicación del último.
Si (index => cantidad) index = -1
// Atar el siguiente al anterior
Si (index <> -1)
nodo.siguiente.anterior = nodo.anterior
sino
ultimo = nodo.anterior
fin si
//Al llegar aquí a anterior y siguiente están enlazados 2 nodos (si no eran primero ni último)... (ellos entre sí y el nodo a eliminar),
// ahora se puede romper los enlaces del nodo a eliminar, porque ahora la lista seguirá doblemente enlazada.
// desatar 'anterior' del nodo (esto es, si no es el primero).
Si (index>0)
nodo.anterior = null
fin si
// desatar 'siguiente' del nodo (esto es, si no es el último)
Si (index> -1)
nodo.siguiente = null
fin si
//Al llegar aquí el nodo está suelto, sin estar sujero a ningún otro, ahora puede eliminarse tranquilamente.
nodo = null
fin funcion
Las funciones adicionales: buscarNodo, elimianrPrimero, EliminarUltimo...
// Deriva a eliminarIndex
Funcion EliminarPrimero
llamada a Eliminar(0)
fin funcion
// Deriva a EliminarIndex
Funcion EliminarUltimo
llamada a Eliminar(-1)
Fin funcion
// Localiza el nodo por el índice que ocupa, recorriendo desde el comienzo o desde el final (lo que quede más cerca).
nodo = funcion Buscarnodo(entero index)
entero k
nodo n
// Desde fuera no es obligatorio saber el índice del último,
// pero una vez dentro sí, así asignamos el índice exacto...
Si ((index<0) o (index > (cantidad-1)))
index = (cantidad-1)
fin si
// se llegaría a él antes, reccorriendo desde el primero o desde el último?
// (basta saber si index queda por debajo o encima de la mitad...
// se puede expresar de diferentes maneras, aquí forzando un valor positivo o negativo).
Si ((index - (cantidad/2) ) < 0)
n= primero
hacer mientras (k <> index)
k +=1
n = nodo.siguiente
repetir
sino
n = ultimo
hacer mientras (k<> index)
k -= 1
n = nodo.anterior
repetir
fin si
devolver n
fin funcion