Instalacion y Configuración
Metodología de Programación

Implementar una cola circular y realizar operaciones básicas en C++

En este ejercicio de C++, implementará una estructura de datos de cola circular. Una cola circular es un tipo de cola donde el último elemento apunta al primero, formando una estructura circular. Esto resulta útil para gestionar datos eficientemente cuando la cola opera de forma circular, como en la gestión de recursos. El ejercicio implicará implementar operaciones básicas como insertar y retirar datos de la cola, y comprobar si la cola está llena o vacía.

Grupo

Estructuras de Datos: Pilas y Colas en C++

Ojetivo

1. Cree una clase para implementar una cola circular de tamaño fijo.
2. Implemente las siguientes operaciones:
- `enqueue`: Añadir un elemento a la cola.
- `dequeue`: Eliminar un elemento de la cola.
- `isFull`: Comprobar si la cola está llena.
- `isEmpty`: Comprobar si la cola está vacía.
3. Utilice un array circular para representar la cola, con punteros para los elementos frontal y posterior.
4. Pruebe la cola realizando las operaciones e imprimiendo los resultados.

Desarrolle una cola circular y realice las operaciones correspondientes.

Ejemplo de Código C++

 Copiar Código C++ 
#include <iostream>  // Include for input/output operations
using namespace std;

class CircularQueue {
private:
    int* queue;  // Pointer to the array that holds the queue elements
    int front;   // Index for the front of the queue
    int rear;    // Index for the rear of the queue
    int capacity;  // Maximum size of the queue
    int size;  // Current size of the queue

public:
    // Constructor to initialize the queue with a fixed capacity
    CircularQueue(int cap) {
        capacity = cap;  // Set the capacity
        queue = new int[capacity];  // Allocate memory for the queue
        front = 0;  // Initialize front to 0
        rear = -1;  // Initialize rear to -1 (queue is empty)
        size = 0;  // Initialize size to 0
    }

    // Function to check if the queue is full
    bool isFull() {
        return size == capacity;  // Queue is full if size equals capacity
    }

    // Function to check if the queue is empty
    bool isEmpty() {
        return size == 0;  // Queue is empty if size is 0
    }

    // Function to add an element to the queue
    void enqueue(int element) {
        if (isFull()) {  // Check if the queue is full
            cout << "Queue is full! Cannot enqueue." << endl;
            return;  // Do nothing if the queue is full
        }
        rear = (rear + 1) % capacity;  // Update rear (circular increment)
        queue[rear] = element;  // Insert the new element
        size++;  // Increment the size of the queue
        cout << "Enqueued: " << element << endl;
    }

    // Function to remove an element from the queue
    void dequeue() {
        if (isEmpty()) {  // Check if the queue is empty
            cout << "Queue is empty! Cannot dequeue." << endl;
            return;  // Do nothing if the queue is empty
        }
        cout << "Dequeued: " << queue[front] << endl;  // Print the dequeued element
        front = (front + 1) % capacity;  // Update front (circular increment)
        size--;  // Decrement the size of the queue
    }

    // Function to display the queue elements
    void display() {
        if (isEmpty()) {  // Check if the queue is empty
            cout << "Queue is empty!" << endl;
            return;  // Do nothing if the queue is empty
        }
        cout << "Queue elements: ";
        for (int i = 0; i < size; i++) {
            cout << queue[(front + i) % capacity] << " ";  // Print elements in circular order
        }
        cout << endl;
    }
};

// Main function to test the CircularQueue class
int main() {
    CircularQueue q(5);  // Create a circular queue with capacity 5

    q.enqueue(10);  // Enqueue elements
    q.enqueue(20);
    q.enqueue(30);
    q.enqueue(40);
    q.enqueue(50);

    q.display();  // Display the queue

    q.enqueue(60);  // Attempt to enqueue when the queue is full

    q.dequeue();  // Dequeue elements
    q.dequeue();

    q.display();  // Display the queue after dequeue operations

    q.enqueue(60);  // Enqueue new elements after dequeue
    q.enqueue(70);

    q.display();  // Display the final state of the queue

    return 0;
}

 Salida

Enqueued: 10
Enqueued: 20
Enqueued: 30
Enqueued: 40
Enqueued: 50
Queue elements: 10 20 30 40 50
Queue is full! Cannot enqueue.
Dequeued: 10
Dequeued: 20
Queue elements: 30 40 50
Enqueued: 60
Enqueued: 70
Queue elements: 30 40 50 60 70

Comparte este ejercicio C++

Más ejercicios de programación C++Estructuras de Datos: Pilas y Colas en C++

¡Explora el conjunto de ejercicios de programación en C++! Diseñados específicamente para principiantes, estos ejercicios te ayudarán a desarrollar una sólida comprensión de los fundamentos de C++. Desde variables y tipos de datos hasta estructuras de control y funciones simples, cada ejercicio está diseñado para desafiarte gradualmente a medida que adquieres confianza en la programación en C++.