结论:

    某元素前方的个数 = (元素index - 首指针  + 数组长度)% 数组长度

和求元素的总数思路一样,你可以认为求当前元素的前方元素(不包含当前元素)的个数, 即为求尾指针rear = index时的元素个数,而这就是求元素总数. 

换句话说, 我就是想知道插入index元素的时候的总数(就算有出队操作).

尾指针指向最后插入元素的下一个位置,在我的循环队列中留一个位置用以判断队满.

 

图示:

                          

JAVA 实现:

循环队列类.

package run;

public class Queue {
	private static int MAXLen = 10;  //队列长度
	
	private int front ; //指向队头
	
	private int rear;  //指向队尾的下一个位置。

	private int num; //当前元素数量
	private Object queueList[];
	public Queue() {
		this(MAXLen);
	}
	public Queue(int MaxLen) {
		queueList = new Object[MaxLen];
	}
	/**判空 */
	public boolean isEmpty() {   
		if(front == rear) {
			return true;
		}
		return false;
	}
	/**判满 */
	public boolean isFull() {  
		if(front==(rear+1)%queueList.length) { // 0 == (2+1) % 3==0			
			System.out.println("队列已满");
			return true;
		}
		return false;
	}
	/**添加元素*/
	public boolean enqueue(Object obj) {
		if(isFull()) {	
			return false;
		}
		queueList[rear]=obj;
		System.out.println("添加的对象为:"+obj.toString());
		rear = (rear+1)%queueList.length;
		num ++;
		return true;
	}
	/**取出头部元素   注意非空判断*/
	public Object dequeue() {
		if(isEmpty()){
			return null;  
		}	
		Object o = queueList[front];
		//queueList[front] =null;
        front=(front+1)%queueList.length;
        num--;
        return o;
	}
	/**获得队列已有元素总数*/
	public int getNum() {
		return num;
	}
	/**获取头指针*/
	public int getFront() {
		return front;
	}
	/**获取尾指针*/
	public int getRear() {
		return rear;
	}
	/**获取指定元素的前面元素总数*/
	public int getYourFront(Object obj) {
		int index = getYourIndex(obj);
		if(index==-1) {
			return 0;
		}
		int numbers = (index-this.front+Queue.MAXLen)% Queue.MAXLen;
		return numbers;	
	}
	/**获取指点元素的下标**/
	public int getYourIndex(Object obj) {
		int index=getIndex(queueList,obj);
		return index;	
	}
	public static int getIndex(Object[] arr, Object value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(value)) {
                return i;
            }
        }
        return -1;//如果未找到返回-1
    }

}

主函数

package run;


public class test {

	public static void main(String[] args) {
		Queue que = new Queue();	
    	        que.enqueue("1");
    	        que.enqueue("2");
    	        que.enqueue("3");
    	        que.enqueue("4");
    	        //队列中剩余
    	        que.enqueue("5");
    	        que.enqueue("6");
    	        que.enqueue("7");
    	        que.enqueue("8");
    	        que.enqueue("9");
    	        que.enqueue("10"); //满
    	        System.out.println("取出头对象:"+que.dequeue().toString());
		System.out.println("取出头对象:"+que.dequeue().toString());
		System.out.println("取出头对象:"+que.dequeue().toString());
		System.out.println("取出头对象:"+que.dequeue().toString());
		A a = new A();
		a.setName("xiong");
		a.setPassword("aaa");
		a.setSex("222");
		A b = new A();
		b.setName("xiong");
		b.setPassword("bbbbb");
		b.setSex("222");
		A C = new A();
		C.setName("JJJJJJ");
		C.setPassword("cccc");
		C.setSex("222");
		que.enqueue(a);
		que.enqueue(b);
		System.out.println("队列总数:"+que.getNum());
		System.out.println("首指针:"+que.getFront());
		System.out.println("尾指针:"+que.getRear());
		//获取元素前面的位置
		System.out.println("a对象的位置是:"+que.getYourIndex(a));
		System.out.println("a对象前方元素个数:"+que.getYourFront(a));
		System.out.println("b对象的位置是:"+que.getYourIndex(b));
		System.out.println("b对象前方元素个数:"+que.getYourFront(b));
		System.out.println("c对象的位置是:"+que.getYourIndex(C));
		System.out.println("C对象前方元素个数:"+que.getYourFront(C));
		System.out.println("9 的位置是"+que.getYourIndex("9"));
		System.out.println("9对象前方元素个数:"+que.getYourFront("9"));
	}

}

结果展示