Question

IN C#

The fun for today is to build your own circular array to support a queue.

The challenge here is in adjusting your queueFront and queueRear markers (they are just integer array indices), and dealing with what happens when they wrap around the First/last element of the array.

The tricky part here is worrying about the edge cases.

There are only two methods you need to fix up

addBack – this should correctly add an item at the rear of the queue without overwriting any other elements, and then correctly update the queueRear Index

removeFront should remove the first element of the Array (note that I give you code on how to a basic case)

The advanced problem is to figure out when and how to grow the array, if at all.

Here is the code:

public class CircularArray<T>
{
private T[] array;
private int queueFront;
private int queueRear;
// Basic Constructor
// Creates an array and initializes the front and rear
// O(1) in time O (N) in size
public CircularArray(int size)
{
array = new T[size + 1];
queueFront = 0;
queueRear = 0;
}
// NYI fully.  
public void addBack(T value) //addBack is enqueue
{

array[queueRear] = value;
queueRear++;// Also inadequate

}
//Also NYI fully
// Note that I've made it return the value being removed, that's not strictly required but makes the most sense.
public T removeFront() //removeFront is dequeue
{
//Right now calling this on an empty queue will crash
T sample = array[queueFront];
// Because technically T could be not nullable we need to use default(T), which is null.  
array[queueFront] = default(T);
queueFront++; // this is inadequate, need to watch wraparound
return sample;
}

// Just returns the front element O(1)
public T getFront()
{
//Calling this on an empty queue will probably crash too
return array[queueFront];
}
// Same old Grow, bit hard to know where to use it if at all though...
// O(N)
public void grow(int newsize)
{
Array.Resize(ref array, newsize);
}

}

class Program
{
static void Main(string[] args)
{
CircularArray<String> Demo;
int numelemnts = 10;
Demo = new CircularArray<String>(numelemnts);

Demo.addBack("Richard");
String deleted = Demo.removeFront();
Console.WriteLine("The following was just removed: " + deleted);
//Demo.removeFront(); works by itself on a line, the result just doesn't go anywhere.  
Demo.addBack("Brian");
Demo.addBack("Bonnie");
Demo.addBack("Sabine");
Demo.addBack("Jamie");
Demo.addBack("Wenying");
Demo.addBack("Omar");

Console.WriteLine(Demo.getFront());
Console.ReadLine();

}
}

Answer 1

using System;

class MainClass {
  public static void Main (string[] args) {
        CircularArray<String> Demo;
        int numelemnts = 3;
        Demo = new CircularArray<String>(numelemnts);

        Demo.addBack("Richard");
        String deleted = Demo.removeFront();
        Console.WriteLine("The following was just removed: " + deleted);

        //Demo.removeFront(); works by itself on a line, the result just doesn't go anywhere.  
        Demo.addBack("Brian");
        Demo.addBack("Bonnie");

        Console.WriteLine(Demo.removeFront());
        Console.WriteLine(Demo.removeFront());

        Demo.addBack("Sabine");
        Demo.addBack("Jamie");
        Demo.addBack("Wenying");
        Demo.addBack("Omar");

        Console.WriteLine(Demo.removeFront());
        Console.WriteLine(Demo.removeFront());
        Console.WriteLine(Demo.removeFront());
        Console.WriteLine(Demo.removeFront());

  }
}


///////////////////////////////////////////////

using System;

public class CircularArray<T>
{
        private T[] array;
        private int queueFront;
        private int queueRear;

        // Basic Constructor
        // Creates an array and initializes the front and rear
        // O(1) in time O (N) in size
        public CircularArray(int size)
        {
                array = new T[size];
                queueFront = -1;
                queueRear = -1;
        }

        public void addBack(T value) //addBack is enqueue
        {
                int size = array.Length;
                if ((queueFront == 0 && queueRear == size-1) ||
                        (queueRear == (queueFront-1)%(size-1))) {
                        //Queue is Full
                        grow(2 * size);
                        addBack(value);
                        return;
                } else if(queueFront == -1) {
                        // empty queue
                        queueFront = queueRear = 0;
                        array[queueRear] = value;
                }  else if(queueRear == size-1 && queueFront != 0) {
                        queueRear = 0;
                        array[queueRear] = value;
                }  else {
                        queueRear += 1;
                        array[queueRear] = value;
                }
        }

        //Also NYI fully
        // Note that I've made it return the value being removed, that's not strictly required but makes the most sense.
        public T removeFront() //removeFront is dequeue
        {
                if(queueFront == -1) {
                        return default(T);
                }
                T data = array[queueFront];

                if(queueFront == queueRear) {
                        // single element
                        queueFront = -1;
                        queueRear = -1;
                } else if (queueFront == array.Length-1) {
                        queueFront = 0;
                } else {
                        queueFront++;
                }
                return data;
        }

        // Just returns the front element O(1)
        public T getFront()
        {
                if(queueFront != -1) {
                        return array[queueFront];
                } else {
                        return default(T);
                }
        }

        // Same old Grow, bit hard to know where to use it if at all though...
        // O(N)
        public void grow(int newsize)
        {
                T[] newArray = new T[newsize];
                int count = 0;

                if (queueRear >= queueFront) {
                        for (int i = queueFront; i <= queueRear; i++) {
                                newArray[count++] = array[i];
                        }
                } else {
                        for (int i = queueFront; i < array.Length; i++) {
                                newArray[count++] = array[i];
                        }
                        for (int i = 0; i <= queueRear; i++) {
                                newArray[count++] = array[i];
                        }
                }

                if(count == 0) {
                        queueFront = queueRear = -1;
                } else {
                        queueFront = 0;
                        queueRear = count - 1;
                }

                array = newArray;
        }

}

Hi. please find the answer above.. i have given comments so that it is very easy for you to understand the flow. In case of any doubts, please ask in comments. If the answer helps you, please upvote. Thanks!

Mono C# compiler version 4.0.4.0 share saved CircularArray.cs 35 The following was just removed: Richard Brian Bonnie Sabine Jamie Wenying Omar else t queueRear 1; array[queueRear] = value; 37 39 //Also NYI fully // Note that I've made it return the value being removed, that's not strictly required but makes the most sense public T removeFront() //removeFront is dequeue 41 43 45 46 47 48 49 50 51 return default(T); T data -array[queueFront]; if(queueFront = queueRear) { // single element queueFront - -1; queueRear1 54 else if (queueFrontarray.Length-1) queueFront0; else t 57 queueFront++ 58 return data; 61 /I Just returns the front element 0(1) public T getFront() 64