Implementación De Una Cola Usando Una Matriz - Ejercicio De Programacion C# Sharp

En este ejercicio, deberás implementar una cola (queue) en C#. Una cola es una estructura de datos que sigue el principio FIFO (First In, First Out), es decir, el primer elemento en entrar es el primero en salir. En este ejercicio, tendrás que crear una clase para la cola, que permita insertar elementos en el final de la cola y eliminar elementos desde el frente. El objetivo de este ejercicio es familiarizarte con las estructuras de datos en C# y cómo gestionarlas de manera eficiente.

El ejercicio también te permitirá practicar la implementación de métodos clave como Enqueue (para agregar elementos), Dequeue (para eliminar elementos) y Peek (para ver el elemento al frente sin eliminarlo). Además, aprenderás a manejar casos como cuando la cola esté vacía o llena, y cómo manejar estos eventos en tu aplicación para evitar errores.

Al completar este ejercicio, comprenderás cómo utilizar las colas en C# y cómo aplicarlas en situaciones prácticas como la gestión de tareas o el procesamiento de datos en orden de llegada.

 Categoría

Gestión Dinámica de Memoria

 Ejercicio

Implementación De Una Cola Usando Una Matriz

 Objectivo

Implementación de una cola

 Ejemplo Ejercicio C#

 Copiar Código C#
// Importing necessary namespace for basic functionalities
using System; // For basic functionalities like Console

// Class that implements a Queue using an array
class Queue
{
    private int[] queueArray; // Array to hold the queue elements
    private int front;        // Index for the front of the queue
    private int rear;         // Index for the rear of the queue
    private int capacity;     // Maximum capacity of the queue
    private int size;         // Current size of the queue

    // Constructor to initialize the queue with a given capacity
    public Queue(int capacity)
    {
        this.capacity = capacity;          // Set the queue's maximum capacity
        queueArray = new int[capacity];    // Initialize the array to hold the queue elements
        front = 0;                         // Front of the queue is initially at index 0
        rear = -1;                         // Rear of the queue is initially empty
        size = 0;                          // The queue is initially empty
    }

    // Method to add an element to the queue
    public void Enqueue(int element)
    {
        if (size == capacity) // Check if the queue is full
        {
            Console.WriteLine("Queue is full! Cannot enqueue.");
            return;
        }
        rear = (rear + 1) % capacity; // Circular increment of the rear index
        queueArray[rear] = element;   // Add the new element to the rear of the queue
        size++;                       // Increase the size of the queue
        Console.WriteLine($"Enqueued: {element}");
    }

    // Method to remove an element from the queue
    public void Dequeue()
    {
        if (size == 0) // Check if the queue is empty
        {
            Console.WriteLine("Queue is empty! Cannot dequeue.");
            return;
        }
        int dequeuedElement = queueArray[front]; // Get the element at the front of the queue
        front = (front + 1) % capacity; // Circular increment of the front index
        size--; // Decrease the size of the queue
        Console.WriteLine($"Dequeued: {dequeuedElement}");
    }

    // Method to display all elements in the queue
    public void DisplayQueue()
    {
        if (size == 0) // Check if the queue is empty
        {
            Console.WriteLine("Queue is empty.");
            return;
        }

        Console.WriteLine("Queue contents:");
        int current = front;
        for (int i = 0; i < size; i++)
        {
            Console.WriteLine(queueArray[current]); // Display each element
            current = (current + 1) % capacity; // Move to the next element (circular)
        }
    }
}

// Main program to demonstrate the Queue functionality
class Program
{
    static void Main(string[] args)
    {
        // Create a queue with a capacity of 5
        Queue queue = new Queue(5);

        // Menu to allow user to interact with the queue
        while (true)
        {
            Console.WriteLine("\nMenu:");
            Console.WriteLine("1. Enqueue an element");
            Console.WriteLine("2. Dequeue an element");
            Console.WriteLine("3. Display the queue");
            Console.WriteLine("4. Exit");
            Console.Write("Enter your choice: ");
            string choice = Console.ReadLine();

            if (choice == "1")
            {
                // Prompt user to enter an element to enqueue
                Console.Write("Enter an element to enqueue: ");
                int element = int.Parse(Console.ReadLine());
                queue.Enqueue(element); // Enqueue the element
            }
            else if (choice == "2")
            {
                // Dequeue an element
                queue.Dequeue(); // Dequeue the element
            }
            else if (choice == "3")
            {
                // Display the current queue
                queue.DisplayQueue(); // Show the current elements in the queue
            }
            else if (choice == "4")
            {
                // Exit the program
                break;
            }
            else
            {
                // Invalid choice
                Console.WriteLine("Invalid choice. Please try again.");
            }
        }
    }
}

 Salida

Menu:
1. Enqueue an element
2. Dequeue an element
3. Display the queue
4. Exit
Enter your choice: 1
Enter an element to enqueue: 1
Enqueued: 1

Menu:
1. Enqueue an element
2. Dequeue an element
3. Display the queue
4. Exit
Enter your choice: 3
Queue contents:
1

Menu:
1. Enqueue an element
2. Dequeue an element
3. Display the queue
4. Exit
Enter your choice: 2
Dequeued: 1

Menu:
1. Enqueue an element
2. Dequeue an element
3. Display the queue
4. Exit
Enter your choice: 2
Queue is empty! Cannot dequeue.

Menu:
1. Enqueue an element
2. Dequeue an element
3. Display the queue
4. Exit
Enter your choice: 4

 Comparte este Ejercicio C# Sharp

 Más Ejercicios de Programacion C# Sharp de Gestión Dinámica de Memoria

¡Explora nuestro conjunto de ejercicios de programación C# Sharp! Estos ejercicios, diseñados específicamente para principiantes, te ayudarán a desarrollar una sólida comprensión de los conceptos básicos de C#. Desde variables y tipos de datos hasta estructuras de control y funciones simples, cada ejercicio está diseñado para desafiarte de manera gradual a medida que adquieres confianza en la codificación en C#.

  •  Implementar una pila usando una matriz

    En este ejercicio, deberás implementar una pila (stack) en C#. Una pila es una estructura de datos que sigue el principio LIFO (Last In, First Out), es decir, ...

  •  Colecciones de colas

    En este ejercicio, deberás crear una cola de cadenas utilizando la clase Queue que ya existe en la plataforma DotNet. La clase Queue es una implementación de l...

  •  Notación Polish inversa de pila de cola

    En este ejercicio, deberás crear un programa que lea una expresión en Notación Polaca Inversa (RPN, por sus siglas en inglés) desde un archivo de texto, como por ejemplo:

  •  ArrayList

    En este ejercicio, deberás crear una lista de cadenas utilizando la clase ArrayList que ya existe en la plataforma .NET. La clase ArrayList permite almacenar e...

  •  ArrayList duplicar un archivo de texto

    En este ejercicio, deberás crear un programa que lea el contenido de un archivo de texto y lo almacene en otro archivo de texto, pero invirtiendo el orden de las líneas. Est...

  •  Suma ilimitada

    En este ejercicio, deberás crear un programa que permita al usuario ingresar una cantidad ilimitada de números. Además de ingresar números, el programa debe permitir al usua...