Queue implementation in C# [closed]

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)