Вставить и удалить элемент в циклической очереди

ГИГО!
Ваш код слишком сложный.
Сложный код требует сложного тестирования и отладки.

Попробуйте следующий код:

void enqueue( struct queue *q, int v) {
    int r = (q.rear + 1) % SIZE
    if (( r == q.front) {
        printf( "Queue is full!\n");
    } else {
        q.val[ q.rear] = v;
        q.rear = r;
    }
};

int dequeue( struct queue *q) {
    if ( q.front == q.rear) {
        printf( "Queue is Empty");
        v = NULL; # or whatever (required as a return value)
    } else {
        v = q.val[ q.front];
        q.front = ( q.front + 1) % SIZE;
    }
    return v;
};

int main() {
    queue *q = new queue;
    q->front = q->rear = 0;
    ...
};

Обобщить:

• задний - индекс самого молодого элемента
• front - это индекс самого старого элемента
• % (оператор модуля) заботится о переносе индекса.
• (спереди == сзади) означает пустой буфер
• ((задний +1) % SIZE == передний) означает полный буфер.

Обратите внимание, что этот простой алгоритм всегда оставляет неиспользуемый элемент в буфере. Это необходимо для того, чтобы отличить «полный» от «пустой».

Ваш код чрезмерно и тупо сложен. Я думаю, вы плохо понимаете круговые очереди.

Вот мой упрощенный код. Вы можете проверить это и узнать что-то.

#include<stdio.h>
#include<stdlib.h>

typedef struct _node {
    int size,front,rear,*q;
} node;

node *pu;

void initialize() {
    if (pu!=NULL)
        free(pu);
    pu = (node *)malloc(sizeof(node));
    printf("\nEnter the size of the queue :- ");
    scanf(" %d",&pu->size);
    pu->q = (int *)malloc(sizeof(int) * pu->size +1);
    pu->front = pu->rear = 0;
}

int isempty() {
    return (pu->front == pu->rear);
}

int isfull() {
    return ((pu->rear + 1) % pu->size == pu->front);
}

void enqueue(int x) {
    if (isfull())
        return;
    else {
        pu->q[pu->rear=(pu->rear +1) % pu->size] = x;
    }
}

int dequeue() {
    if (isempty())
        return '$';
    else {
        return pu->q[ pu->front = (pu->front + 1) % pu->size];
    }
}

void display() {
    if (isempty())
        return;
    else {
        for( int i = pu->front + 1; i != (pu->rear +1)%pu->size ; i = ( i +1) % pu->size)
            printf("\n %d",pu->q[i]);
    }
}

int main() {
    // do something in here with the functions.
    return 0;
}

Циклическая очередь в Java

public class CircularQueue<T> {

    private Object[] arr;
    private int front = -1, rear = -1;

    public CircularQueue(int initialCapacity) {
        this.arr = new Object[initialCapacity];
    }

    public void add(T val) throws Exception {
        if (isEmpty()) {
            rear++;
            front++;
        } else if (isFull()) {
            throw new Exception("Queue is full");
        }
        arr[rear] = val;
        rear = (rear + 1) % arr.length;
    }

    public T delete() throws Exception {
        if (isEmpty()) {
            throw new Exception("No elements in Queue");
        }
        T temp = (T) arr[front];
        front = (front + 1) % arr.length;
        return temp;
    }

    public boolean isEmpty() {
        return (front == -1 && rear == -1);
    }

    public boolean isFull() {
        return (front == rear);
    }

    @Override
    public String toString() {
        String ret = "[ ";
        int temp = front;
        do {
            ret += arr[temp] + " ";
            temp = (temp + 1) % arr.length;
        } while (temp != rear);
        ret += "]";
        return ret;
    }

}