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:
- Crea una clase llamada
Pila
que permita apilar y desapilar elementos.
- Crea una clase llamada
Cola
que permita insertar y eliminar elementos en orden.
- En el método principal, crea objetos de tipo
Pila
y Cola
, inserta y elimina elementos, y muestra el resultado de cada operación.
- 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.
Ver código de ejemplo
// 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.