Circular Queue without wasting an entry or using counter

Your concerns are usually recognized as the full vs. empty difficulty of circular queues. Quoting:

To solve this confusion there are a number of solutions:

1. Always keep one slot open.
2. Use a fill count to distinguish the two cases.
3. Use an extra mirroring bit to distinguish the two cases.
4. Use read and write counts to get the fill count from.
5. Use absolute indices.
6. Record last operation.

Numbers 1, 2, and 4 you address directly in your question. They do consume certain amounts of memory aside from the array and start/end (or front/rear as you name them) indices/pointers. The other solutions also consume memory.

#3 - use a mirroring bit

Only adds one extra boolean or enum, essentially isEmpty or isFull. The idea, logic and proof of this approach is more complicated.

#5 - absoulte indices

Indices are incremented when an operation is performed and never reduced. They are essentially counters of the number of operations of each type performed. This has other drawbacks.

#6 - record last operation

Essentially the same as #3, but different semantics.

Anyways, all those links are to the wikipedia article. I highly recommend it. There may be other approaches, but it would be hard to improve on one of the 6 approaches outlined in your article. They all have drawbacks as well as advantages, so think carefully about the intended use case before settling on an implementation.

As I once implemented it I used an additional bool called 'empty'. You are right, one can not distinguish in the case that both pointers are at the same location.

Depending on what pointers you use, you could use the lowest bit of one pointer to store the empty variable.
In case size is a variable integer you could also use a negative value to indicate that the queue has no elements.

at the start, let first=0, rear=-1;

we add it the following way..... array[rear]; rear=(rear+1)%MAX;

we remove it the following way.. array[front]; front=(front+1)%MAX;

while removing an element from the array, we can add a condition after it as follows...
if(front==rear+1) first=0, rear=-1

then the empty condition can be given as...

if(rear==-1) printf("Empty");

the full condition will be then...

if ( ( front==(rear+1) || (front==0 && rear==(n-1) ) && rear!=-1 ) printf("Full");

this might work. no "count" function used

An alternative is to use three pointers, where the third pointer points to a place in-between the two pointers. There are a number of ways this could be implemented. The key thing to note though is that the middle pointer only needs to tell the following two things.

• The queue is empty. All pointers point to the same place (the second definition for rear pointer).
• The queue has 1 element and removing an element will make it empty. Middle pointer and another pointer points to the same place.

This can simply be done by keeping the middle pointer in between the first and last, and offset by one from either the first or last pointer as long as the queue has 1 or more elements.

This is probably at best only a slight improvement to using a counter, and may even be worst.