Queue implementation in C# [closed]

Question

I have tried to implement a queue from scratch, and it doesn't really seem to match what i found on internet, and I am wondering if this is a correct implementation, and what makes using Stack different from Linked Lists?

namespace DataStructures
{
    internal class Queuez<T>
    {
        static int MAX = 1000;
        int back;
        int front = 0;
        T[] queue = new T[MAX];

        public void PrintValues()
        {
            for (int i = front; i < back; i++)
            {
                Console.WriteLine(queue[i]);
            }
        }
        public void Enqueue(T val)
        {
            queue[back++] = val;
        }
        public T? Dequeue()
        {
            T first;
            if (back < front)
            {
                return default(T?);
            }
            else
            {
                first = queue[front];
                front++;
            }
            return first;
        }
        public void Count()
        {
            Console.WriteLine(back < front ? 0 : back - front);
        }
        public void Clear()
        {
            back = 0;
        }
        public bool Contains(T val)
        {
            for (int i = front; i < back; i++)
            {
                if (EqualityComparer<T>.Default.Equals(queue[i], val))
                {
                    return true;
                }
            }
            return false;
        }
        public T? Peek()
        {
            return back < front ? default(T) : queue[front];
        }
        public bool isEmpty()
        {
            return back <= front;
        }
    }
}
```

Answer 1

Stack and linked lists cannot be compared because they represent different levels of abstraction. You could implement a stack with a linked list or an array. You could, however, compare arrays and linked lists, because they are on the same level of abstraction or stacks with queues.

But this has nothing to do with Queues. Your implementation has the problem that you are not reusing the space. When back has reached the end, you cannot continue using it, even if Count is smaller than queue.Length.

You should implement a Circular buffer by wrapping around. This is best done with the modulo operator %.

internal class Queuez<T>
{
    static int CAPACITY = 1000;
    int back;
    int front;
    int count;
    T[] queue = new T[CAPACITY];

    public void Enqueue(T val)
    {
        if (count < CAPACITY) {
            queue[back] = val;
            back = (back + 1) % CAPACITY;
            count++;
        } else {
            throw new InsufficientMemoryException();
        }
    }

    public T? Dequeue()
    {
        if (count > 0) {
            T value = queue[front];
            front = (front + 1) % CAPACITY;
            count--;
            return value;
        }
        return default;
    }

    public void Count => count;

    public void Clear()
    {
        back = 0; front = 0; count = 0;
    }

    public bool Contains(T val)
    {
        for (int i = front, i != back; i = (i + 1) % CAPACITY)
        {
            if (EqualityComparer<T>.Default.Equals(queue[i], val))
            {
                return true;
            }
        }
        return false;
    }

    public T? Peek()
    {
        return count == 0 ? default(T) : queue[front];
    }

    public bool IsEmpty => count == 0;
}

Also, when clearing, you must set both back and front to 0 (and in my implementation also count).

I renamed MAX to CAPACITY because the maximum index would be CAPACITY - 1.

Because front could be ahead of back legally because of the wrapping around, this makes calculating the count from these two variables not so easy. Therefore, I used the more direct approach to store the count in a field.

Note that I don't test i < back in the for-loop of the Contains method, since i could be ahead of back (again because of the wrapping around). Instead, I test i != back.

(I have neither compiled nor not tested this code)