Laboratorio de Tecnología de Objetos

Práctica 3
El objetivo de este ejercicio es el de crear clases que implementen pilas de números enteros.
Como en otros lenguajes es posible crear versiones estáticas y dinámicas de dicha estructura
de datos, aquí proponemos la realización de ambas versiones en Java.
El protocolo (común) de las clases será el siguiente:

public void insertar(int n)
// Añade un entero a la pila
public int cima()
// Devuelve el elemento en la cima de la pila (sin modificarla)
public void extraer()
// Extrae el elemento en la cima de la pila
public boolean vacía()
// Devuelve true si la lista está vacía
public String toString()
// Crea un String que representa a la lista en su estado actual

1. Realizar una implementación estática de la pila, de forma que ésta esté representada como un
array de enteros y un índice que indique dónde se almacena el último dato almacenado.
Impleméntese un constructor que tome como parámetro el tamaño del array, es decir, el número
máximo de elementos a almacenar en la pila.
PilaEnterosEstatica
-elementos : int[]
-tope : int
+PilaEnterosEstatica( n : int )
+insertar( d : int ) : void
+extraer() : void
+cima() : int
+vacía() : boolean
+llena() : boolean
+toString() : String

La aplicación TestPilaEnterosEstatica será la siguiente:

public class TestPilaEnterosEstatica {
static final int TAMAÑO = 3;

public static PilaEnterosEstatica invertir(PilaEnterosEstatica p) {
// Completar
}

public static void main(String[] args) {
PilaEnterosEstatica p = new PilaEnterosEstatica(TAMAÑO);
System.out.println(p);
for (int i = 0; i < TAMAÑO; i++) {
p.insertar(i);
System.out.println(p);
}
PilaEnterosEstatica p1 = invertir(p);

while (!p.println(p). que contendrán. dato y sig. el dato almacenado en ese nodo de la pila y una referencia al siguiente nodo o null si no hay siguiente. System.out. PilaEnterosDinamica -contador : int Nodo +PilaEnterosDinamica() -dato : int +insertar( d : int ) : void -sig : Nodo primero +extraer() : void +Nodo( d : int ) 0. al primero de los nodos de la pila.println("La pila invertida: " + p1). System. si la pila está vacía esta referencia será null.out. Realizar una implementación enlazada de la pila. .1 +vacía() : boolean +toString() : String +toString() : String +contador() : int sig Las clases tendrán pues la siguiente estructura: public class PilaEnterosDinamica { private static int contador = 0. System.vacía()) { p. respectivamente. protected Nodo sig.. La clase PilaEnterosDinamica tendrá una sola variable de instancia con la que referenciará a un objeto de la clase Nodo. y tendrá dos variables de instancia.1 +cima() : int 0. La clase Nodo será una clase anidada de PilaEnterosDinamica. que contendrá el elemento en la cima de la misma en caso de que no esté vacía. protected class Nodo { protected int dato. de forma que los elementos de la pila se almacenen en una secuencia de nodos enlazados. Esta clase dispondrá a su vez de una variable de clase contador con la que se mantendrá un contador de instancias creadas de la clase PilaEnterosDinamica.out..println("La pila original: " + p). } } } Cuya salida ha de ser: Pila: vacía Pila: 0 Pila: 01 Pila: 012 La pila original: Pila: 012 La pila invertida: Pila: 210 Pila: 01 Pila: 0 Pila: vacía 2.extraer().

").. // .out. } System. 0 . System.out. i < 3.println(p). Pila 0. Pila 0 . // .println("Hay " + p. System.. Pila 2.println(p). 2 . Pila 2 . System.out.contador() + " pilas. i++) { p.contador() + " pilas. System.out. Hay 1 pilas. } } } Con salida: Pila vacía. 1..").println(p1). while (!p1. Hay 2 pilas.. .vacía()) { p1. for (int i = 0. } protected Nodo primero. PilaEnterosDinamica p1 = invertir(p). Pila 1.println(p1). } La aplicación TestPilaEnterosDinamica será la siguiente: public class TestPilaEnterosDinamica { public static PilaEnterosDinamica invertir(PilaEnterosDinamica p) { // Completar } public static void main(String[] args) { PilaEnterosDinamica p = new PilaEnterosDinamica(). 2 . Pila 1.out. System. 1.insertar(i). 0 .out.extraer().println("Hay " + PilaEnterosDinamica. Pila vacía.