Resolución de problemas con pilas con arreglos en java

Las pilas (stacks) son estructuras de datos que siguen el principio LIFO (Last In, First Out), es decir, el último elemento que se agrega es el primero en ser retirado. En Java, puedes implementar una pila utilizando un arreglo. A continuación, se presenta una implementación simple de una pila usando un arreglo, así como ejemplos de cómo resolver problemas típicos con esta estructura de datos.

### Implementación de una Pila usando un Arreglo

Aquí tienes una implementación básica de una pila con un arreglo en Java:

```java
class Pila {
    private int maxSize;
    private int[] stackArray;
    private int top;

    // Constructor para inicializar la pila
    public Pila(int size) {
        maxSize = size;
        stackArray = new int[maxSize];
        top = -1; // Indica que la pila está vacía
    }

    // Método para agregar un elemento a la pila
    public void push(int value) {
        if (top + 1 < maxSize) {
            stackArray[++top] = value;
        } else {
            System.out.println("Error: La pila está llena.");
        }
    }

    // Método para eliminar el elemento superior de la pila
    public int pop() {
        if (top >= 0) {
            return stackArray[top--];
        } else {
            System.out.println("Error: La pila está vacía.");
            return -1; // Retorna -1 si la pila está vacía
        }
    }

    // Método para ver el elemento superior sin eliminarlo
    public int peek() {
        if (top >= 0) {
            return stackArray[top];
        } else {
            System.out.println("Error: La pila está vacía.");
            return -1; // Retorna -1 si la pila está vacía
        }
    }

    // Método para verificar si la pila está vacía
    public boolean isEmpty() {
        return (top == -1);
    }

    // Método para verificar si la pila está llena
    public boolean isFull() {
        return (top + 1 == maxSize);
    }
}
```

### Ejemplo de Uso

Ahora vamos a utilizar esta clase `Pila` para resolver un problema típico: **Evaluar una expresión aritmética en notación postfija**.

#### Evaluar Expresión Postfija

```java
import java.util.Scanner;

public class EvaluarPostfijo {
    public static void main(String[] args) {
        Pila pila = new Pila(100); // Crear una pila con capacidad de 100 elementos
        Scanner scanner = new Scanner(System.in);

        System.out.println("Ingrese una expresión aritmética en notación postfija (separada por espacios):");
        String expresion = scanner.nextLine();
        String[] tokens = expresion.split(" ");

        for (String token : tokens) {
            if (token.matches("\\d+")) {
                // Si el token es un número, lo empujamos a la pila
                pila.push(Integer.parseInt(token));
            } else {
                // Si el token es un operador, hacemos pop de los dos elementos
                int b = pila.pop();
                int a = pila.pop();
                int resultado = 0;

                switch (token) {
                    case "+":
                        resultado = a + b;
                        break;
                    case "-":
                        resultado = a - b;
                        break;
                    case "*":
                        resultado = a * b;
                        break;
                    case "/":
                        resultado = a / b;
                        break;
                    default:
                        System.out.println("Error: Operador no reconocido.");
                }

                // Empujamos el resultado de la operación de nuevo a la pila
                pila.push(resultado);
            }
        }

        // El resultado final debe estar en la parte superior de la pila
        System.out.println("El resultado de la expresión es: " + pila.pop());
    }
}
```

### Instrucciones para Compilar y Ejecutar

1. Copia el código de la clase `Pila` y la clase `EvaluarPostfijo` en un archivo llamado `EvaluarPostfijo.java`.
2. Abre una terminal o consola y navega al directorio donde guardaste el archivo.
3. Compila el programa usando: 
   ```sh
   javac EvaluarPostfijo.java
   ```
4. Ejecuta el programa usando: 
   ```sh
   java EvaluarPostfijo
   ```

5. Ingresa una expresión aritmética en notación postfija separada por espacios (por ejemplo: `3 4 + 2 * 7 /`).

### Consideraciones

- Esta implementación es básica y no maneja errores de manera robusta, como la división por cero o la evaluación de expresiones mal formadas.
- Puedes extender la funcionalidad de la pila añadiendo más métodos o características según sea necesario.

Esta sería una forma sencilla de resolver un problema común usando pilas en Java. Si tienes algún otro problema específico en mente o necesitas expansión en algún tema, ¡déjamelo saber!