Implementing A Queue Using Array - C# Programming Exercise

In this exercise, you need to implement a queue in C#. A queue is a data structure that follows the FIFO (First In, First Out) principle, meaning the first element to enter is the first one to exit. In this exercise, you will need to create a class for the queue, allowing you to insert elements at the end of the queue and remove elements from the front. The goal of this exercise is to familiarize yourself with data structures in C# and how to manage them efficiently.

This exercise will also allow you to practice implementing key methods like Enqueue (to add elements), Dequeue (to remove elements), and Peek (to view the front element without removing it). Additionally, you will learn to handle cases when the queue is empty or full, and how to manage these events in your application to prevent errors.

By completing this exercise, you will understand how to use queues in C# and how to apply them in practical situations like task management or processing data in the order it arrives.

 Category

Dynamic Memory Management

 Exercise

Implementing A Queue Using Array

 Objective

Implementing a queue

 Write Your C# Exercise

// 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.");
            }
        }
    }
}

 Share this C# exercise

 More C# Programming Exercises of Dynamic Memory Management

Explore our set of C# programming exercises! Specifically designed for beginners, these exercises will help you develop a solid understanding of the basics of C#. From variables and data types to control structures and simple functions, each exercise is crafted to challenge you incrementally as you build confidence in coding in C#.

  •  Implementing a stack using array

    In this exercise, you need to implement a stack in C#. A stack is a data structure that follows the LIFO (Last In, First Out) principle, meaning the last eleme...

  •  Queue Collections

    In this exercise, you need to create a string queue using the Queue class that already exists in the DotNet platform. The Queue class is an implementation of t...

  •  Queue Stack Reverse Polish Notation

    In this exercise, you need to create a program that reads a Reverse Polish Notation (RPN) expression from a text file, such as: 3 4 6 5 - + * 6 + (Result 21). In...

  •  ArrayList

    In this exercise, you need to create a string list using the ArrayList class that already exists in the .NET platform. The ArrayList class allows storing items...

  •  ArrayList duplicate a text file

    In this exercise, you need to create a program that reads from a text file and stores it to another text file by reversing the order of the lines. This exercise will ...

  •  Unlimited sum

    In this exercise, you need to create a program that allows the user to enter an unlimited amount of numbers. Besides entering numbers, the program should allow the user to e...