Práctica 2: Pila de enteros

Descripción

Esta actividad puede ser elaborada de manera individual o en parejas.

Escribe una clase llamada mx.itesm.cem.pilas.IntStack. Esta clase representa una estructura de datos de pila que permite contener números enteros.

Una pila o stack es una colección secuencial que funciona con una política LIFO (last in, first out), en donde los elementos se insertan y remueven por un mismo extremo.

Usando un arreglo de enteros, implementa los métodos que se describen a continuación. La clase debe ir en un archivo llamado IntStack.java.

1. public IntStack(int max)

   Constructor que permite crear una nueva pila de números enteros con una capacidad max.

2. public void push(int x)

   Inserta x en el tope de esta pila. Arroja la excepción IllegalStateException con el mensaje "Stack Overflow" si la pila ya está en su máxima capacidad.

3. public int pop()

   Remueve el elemento que se encuentra en el tope de esta pila. Devuelve el elemento removido. Arroja la excepción NoSuchElementException con el mensaje "Stack Underflow" si la pila se encuentra vacía.

4. public int peek()

   Devuelve, pero sin remover, el elemento que se encuentra en el tope de esta pila. Arroja la excepción NoSuchElementException con el mensaje "Stack Underflow" si la pila se encuentra vacía.

5. public boolean isEmpty()

   Devuelve true si esta pila está vacía, false en caso contrario.

6. public int size()

   Devuelve el número de elementos contenidos actualmente en esta pila.

Prueba tu código usando la siguiente clase de JUnit:

package mx.itesm.cem.pilas;

import static org.junit.jupiter.api.Assertions.*;

import java.util.NoSuchElementException;

import org.junit.jupiter.api.Test;

class IntStackTest {

    @Test
    public void test1() {
        IntStack s = new IntStack(5);
        s.push(4);
        assertEquals(4, s.peek());
        s.push(8);
        assertEquals(8, s.peek());
        s.push(15);
        assertEquals(15, s.peek());
        s.push(16);
        assertEquals(16, s.peek());
        s.push(23);
        assertEquals(23, s.peek());
        assertEquals("Stack Overflow",
                assertThrows(IllegalStateException.class,
                        () -> s.push(42)).getMessage());
    }

    @Test
    public void test2() {
        IntStack s = new IntStack(10);
        s.push(4);
        s.push(8);
        s.push(15);
        s.push(16);
        s.push(23);
        s.push(42);
        assertEquals(42, s.peek());
        assertEquals(42, s.pop());
        assertEquals(23, s.peek());
        assertEquals(23, s.pop());
        assertEquals(16, s.peek());
        assertEquals(16, s.pop());
        assertEquals(15, s.peek());
        assertEquals(15, s.pop());
        assertEquals(8, s.peek());
        assertEquals(8, s.pop());
        assertEquals(4, s.peek());
        assertEquals(4, s.pop());
        assertEquals("Stack Underflow",
                assertThrows(NoSuchElementException.class,
                        () -> s.pop()).getMessage());
        assertEquals("Stack Underflow",
                assertThrows(NoSuchElementException.class,
                        () -> s.peek()).getMessage());
    }

    @Test
    public void test3() {
        IntStack s = new IntStack(10);
        assertTrue(s.isEmpty());
        assertEquals(0, s.size());
        s.push(4);
        assertFalse(s.isEmpty());
        assertEquals(1, s.size());
        s.push(8);
        assertFalse(s.isEmpty());
        assertEquals(2, s.size());
        s.push(15);
        assertFalse(s.isEmpty());
        assertEquals(3, s.size());
        s.push(16);
        assertFalse(s.isEmpty());
        assertEquals(4, s.size());
        s.push(23);
        assertFalse(s.isEmpty());
        assertEquals(5, s.size());
        s.push(42);
        assertFalse(s.isEmpty());
        assertEquals(6, s.size());
        assertEquals(42, s.pop());
        assertFalse(s.isEmpty());
        assertEquals(5, s.size());
        assertEquals(23, s.pop());
        assertFalse(s.isEmpty());
        assertEquals(4, s.size());
        assertEquals(16, s.pop());
        assertFalse(s.isEmpty());
        assertEquals(3, s.size());
        assertEquals(15, s.pop());
        assertFalse(s.isEmpty());
        assertEquals(2, s.size());
        assertEquals(8, s.pop());
        assertFalse(s.isEmpty());
        assertEquals(1, s.size());
        assertEquals(4, s.pop());
        assertTrue(s.isEmpty());
        assertEquals(0, s.size());
    }

    @Test
    public void test4() {
        IntStack s1 = new IntStack(10);
        IntStack s2 = new IntStack(10);
        s1.push(4);
        s1.push(8);
        s1.push(15);
        s1.push(16);
        s1.push(23);
        s1.push(42);
        s2.push(s1.pop());
        s2.push(s1.pop());
        s2.push(s1.pop());
        s2.push(s1.pop());
        s2.push(s1.pop());
        s2.push(s1.pop());
        assertTrue(s1.isEmpty());
        assertEquals(4, s2.pop());
        assertEquals(8, s2.pop());
        assertEquals(15, s2.pop());
        assertEquals(16, s2.pop());
        assertEquals(23, s2.pop());
        assertEquals(42, s2.pop());
        assertTrue(s2.isEmpty());
    }
}

¿Qué se debe entregar?

Tu archivo fuente de Java debe comenzar con un comentario que contenga el título de la práctica, la fecha y los datos personales de los autores (nombre y matrícula). Por ejemplo:

/*----------------------------------------------------------
 * Práctica 2: Pila de enteros
 * Fecha: 09-Feb-2018
 * Autores:
 *           A01166611 Pepper Pots
 *           A01160611 Anthony Stark
 *----------------------------------------------------------*/

Si la práctica fue desarrollada en pareja, basta que solo uno de los miembros la entregue.

La fecha límite es el viernes 9 de febrero.

Evaluación

Esta actividad será evaluada usando los siguientes criterios:

-10	No se incluyó en comentario los datos de los autores.
10-100	Dependiendo del número de métodos correctamente implementados.
10	El programa no compila.
1	El programa es un plagio total o parcial.