Circular Queue Visualizer

// Ring buffer: front = 0, rear = N − 1, size = 0 at the startenqueue(x):  if size = N: error "queue full"  rear = (rear + 1) mod N  a[rear] = x; size = size + 1dequeue():  if size = 0: error "queue empty"  x = a[front]  front = (front + 1) mod N; size = size − 1; return xpeek(): return a[front]

class CircularQueue {
    static const int N = 8;
    int a[N]; int front = 0, rear = N - 1, size = 0;
public:
    bool enqueue(int x) {
        if (size == N) return false;          // full
        rear = (rear + 1) % N;
        a[rear] = x; size++;
        return true;
    }
    int dequeue() {
        if (size == 0) throw std::out_of_range("queue empty");
        int x = a[front];
        front = (front + 1) % N; size--;
        return x;
    }
    int peek() const { return a[front]; }
};

class CircularQueue {
    private final int[] a;
    private int front = 0, rear, size = 0;
    CircularQueue(int n) { a = new int[n]; rear = n - 1; }
    boolean enqueue(int x) {
        if (size == a.length) return false;   // full
        rear = (rear + 1) % a.length;
        a[rear] = x; size++;
        return true;
    }
    int dequeue() {
        if (size == 0) throw new IllegalStateException("queue empty");
        int x = a[front];
        front = (front + 1) % a.length; size--;
        return x;
    }
    int peek() { return a[front]; }
}

class CircularQueue:
    def __init__(self, n):
        self.a = [None] * n
        self.n, self.front, self.rear, self.size = n, 0, n - 1, 0

    def enqueue(self, x):
        if self.size == self.n:
            raise OverflowError("queue full")
        self.rear = (self.rear + 1) % self.n
        self.a[self.rear] = x
        self.size += 1

    def dequeue(self):
        if self.size == 0:
            raise IndexError("queue empty")
        x = self.a[self.front]
        self.a[self.front] = None
        self.front = (self.front + 1) % self.n
        self.size -= 1
        return x

class CircularQueue {
  constructor(n) { this.a = new Array(n); this.n = n; this.front = 0; this.rear = n - 1; this.size = 0; }
  enqueue(x) {
    if (this.size === this.n) return false;   // full
    this.rear = (this.rear + 1) % this.n;
    this.a[this.rear] = x;
    this.size++;
    return true;
  }
  dequeue() {
    if (this.size === 0) throw new Error('queue empty');
    const x = this.a[this.front];
    this.front = (this.front + 1) % this.n;
    this.size--;
    return x;
  }
  peek() { return this.a[this.front]; }
}