Añadir elementos en una pila

publicado por: Anonymous

Al ejecutar este codigo me marca un error: Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 0. Entonces en una pila nunca se le podrán añadir objetos a partir de la posición n, n=1,2,…,infinito, siempre se empezara en la posición 0??

Mi idea era que pila.add("("); lo pusiera en la posicion 0.

public static void main(String[] args){


    LinkedList<String> pila=new LinkedList<>();


    pila.add(1,"1");
    pila.add(2,"2");
    pila.add(3,"3");
    pila.add(4,"*");

    pila.add("(");
    System.out.println(pila);
}

solución

Estás intentando añadir un elemento a un índice que no existe

Tu problema radica en que al crear la lista, su tamaño es de 1 nodo (índice 0), pero intentas añadir un elemento al segundo nodo, que no existe. En efecto, deberías empezar a añadir elementos por el índice 0.

Ahora, veo que estás intentando insertar en un índice concreto. Eso es precisamente lo que una pila y una cola intentan evitar.

Una pila es una estructura de tipo LIFO

Las estructuras de tipo LIFO y FIFO no te permiten añadir elementos en una posición arbitraria, sino que la inserción y extracción de datos están siempre ligadas al primer o último elemento.

Están diseñadas para que no tengas que preocuparte de en qué orden están los elementos.

Estructuras de tipo LIFO

LIFO es acrónimo de Last In, First Out. Las pilas cumplen esta norma.

Piensa en una pila como una pila de platos que lavar. El primer plato sucio que colocas se queda abajo. Y cuando los laves, ese primer plato será el último en salir.

Estructuras de tipo FIFO

FIFO es acrónimo de First In, First Out. Las colas cumplen esta norma.

Puedes imaginarte una cola de supermercado. La primera persona que llega a la cola es la primera persona que saldrá.

En cuanto a tu implementación

Si quieres implementar una pila (LIFO), las colecciones de java ofrecen un par de formas:

Utilizar la clase Stack.

Esta clase representa exactamente la pila que tú buscas. pero tiene un problema. Como pone en la documentación, hereda de la clase Vector, una clase que está poco más que olvidada. Además, al heredar y no implementar, obtienes un comportamiento poco flexible y que ofrece cosas que no quieres, algo que no es recomendable.

Utilizar la interfaz Deque y sus implementaciones.

Nota: entre las implementaciones de Deque se encuentra LinkedList

Deque se pronuncia "Deck", es decir "Baraja" y soporta operaciones tanto LIFO como FIFO. Podrías tomarlo como una fusión entre colas y pilas.

Esta interfaz es más moderna y ya no extiende de Vector. Es cierto que Deque ofrece inserción y extracción por ambos extremos, lo cual podría ser más funcionalidad de la que buscas, pero también ofrece flexibilidad a la hora de elegir si quieres una estructura FIFO o LIFO.

En mi opinión, si quieres una estructura Exclusivamente FIFO o LIFO, deberías utilizar esta interfaz y su implementación ArrayDeque.

Un ejemplo de pila:

// Usando un Deque como pila LIFO    
Deque<String> pila = new ArrayDeque<>();
    
pila.push("M"); // Entra primero, sale el ultimo
pila.push("i");
pila.push("c");
pila.push("h");
pila.push("e");
pila.push("l");
pila.push("l");
pila.push("e"); // Entra ultimo, sale el primero       

int size = pila.size();
for (int i = 0; i < size; i++) {
    System.out.println(pila.pop());
}

Salida:

e
l
l
e
h
c
i
M
Respondido por: Anonymous

Leave a Reply

Your email address will not be published. Required fields are marked *