Instalación, Configuración Entorno
Metodología Programación

Pilas y Colas

En este ejercicio, aprenderás a trabajar con **iteradores** y **ciclos** en Java para recorrer colecciones como **Listas**, **Conjuntos** y **Mapas**. Utilizarás estructuras de control como `for`, `while` y `foreach` para acceder y manipular los elementos dentro de estas colecciones, lo que te permitirá manejar grandes volúmenes de datos de manera eficiente y flexible en tus aplicaciones Java.

Tema

Estructuras de Datos y Colecciones

Ejercicio Java

En este ejercicio, crearás un programa en Java que implemente las estructuras de datos **Pilas** y **Colas**. Comenzarás creando una clase para **Pila** que permita apilar y desapilar elementos. Luego, crearás una clase para **Cola** que permita insertar y eliminar elementos en el orden adecuado. Al final, implementarás un programa que demonstre el uso de ambas estructuras para manejar datos de manera eficiente y ordenada.

Instrucciones:

  1. Crea una clase llamada Pila que permita apilar y desapilar elementos.
  2. Crea una clase llamada Cola que permita insertar y eliminar elementos en orden.
  3. En el método principal, crea objetos de tipo Pila y Cola, inserta y elimina elementos, y muestra el resultado de cada operación.
  4. Demuestra cómo estas estructuras de datos pueden ser útiles en situaciones donde el orden de los elementos es crucial.

Este ejercicio te ayudará a comprender cómo las **Pilas** y **Colas** funcionan en Java y cómo se pueden aplicar para resolver problemas en el manejo de datos y control de flujo.


// Clase Pila
class Pila {
    private int maxSize = 10;
    private int top = -1;
    private int[] stack = new int[maxSize];

    public void apilar(int value) {
        if (top < maxSize - 1) {
            stack[++top] = value;
            System.out.println(value + " apilado.");
        } else {
            System.out.println("Pila llena. No se puede apilar.");
        }
    }

    public void desapilar() {
        if (top >= 0) {
            System.out.println(stack[top--] + " desapilado.");
        } else {
            System.out.println("Pila vacía. No se puede desapilar.");
        }
    }

    public boolean estaVacia() {
        return top == -1;
    }
}

// Clase Cola
class Cola {
    private int maxSize = 10;
    private int front = -1;
    private int rear = -1;
    private int[] queue = new int[maxSize];

    public void insertar(int value) {
        if (rear < maxSize - 1) {
            if (front == -1) front = 0;
            queue[++rear] = value;
            System.out.println(value + " insertado en la cola.");
        } else {
            System.out.println("Cola llena. No se puede insertar.");
        }
    }

    public void eliminar() {
        if (front <= rear && front != -1) {
            System.out.println(queue[front++] + " eliminado de la cola.");
            if (front > rear) front = rear = -1; // Cola vacía
        } else {
            System.out.println("Cola vacía. No se puede eliminar.");
        }
    }

    public boolean estaVacia() {
        return front == -1;
    }
}

public class Main {
    public static void main(String[] args) {
        // Crear objetos de Pila y Cola
        Pila pila = new Pila();
        Cola cola = new Cola();

        // Operaciones en Pila
        pila.apilar(10);
        pila.apilar(20);
        pila.desapilar();
        pila.desapilar();
        pila.desapilar(); // Intento de desapilar desde una pila vacía

        // Operaciones en Cola
        cola.insertar(100);
        cola.insertar(200);
        cola.eliminar();
        cola.eliminar();
        cola.eliminar(); // Intento de eliminar desde una cola vacía
    }
}

 Salida:

10 apilado.
20 apilado.
20 desapilado.
10 desapilado.
Pila vacía. No se puede desapilar.
100 insertado en la cola.
200 insertado en la cola.
100 eliminado de la cola.
200 eliminado de la cola.
Cola vacía. No se puede eliminar.

Este programa demuestra cómo se implementan las estructuras de datos de **Pilas** y **Colas** en Java. La clase Pila permite apilar y desapilar elementos, mientras que la clase Cola permite insertar y eliminar elementos en orden. Al ejecutar el programa, se puede observar cómo se gestionan estos elementos en ambas estructuras, siguiendo sus respectivas reglas de comportamiento.


 Comparte este ejercicio JAVA