循环队列（Java实现）

        循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位置已被使用而再要进入队运算时，只需要存储空间的第一个位置空闲，便可将元素加入到第一个位置，即将存储空间的第一个位置作为队尾。队列可以更简单防止伪溢出的发生，但队列大小是固定的。循环队列的使用分两种情况：

        1、牺牲一个存储单元，因为队空时，有front=rear，而当队满时，也是front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front=rear，而队列判满的条件是front=（rear+1)%MaxSize。Java实现代码如下：

               public class CircularQueue {
                       private int MaxSize; //队列的容量
                       private int[] arr; //队列的存储结构(用一维数组作为队列的存储结构)
                       private int front;//队头指针
                       private int rear;//队尾指针
                    

                public CircularQueue(int MaxSize) { //构造一个队列时需要指定队列的容量
                      this.MaxSize = MaxSize;
                      arr = new int[MaxSize];
                      front = 0;
                      rear = 0;
                  }

            //判空
           public boolean isEmpty(){
                return rear == front; //当队头指针赶上队尾指针时
         }

          //判满
         public boolean isFull(){
                return (rear + 1) % MaxSize == front;
         }

        //入队
       public void addElement(int elem){
         try {
              if(isFull()){
                  throw new Exception("队列已满!");
            }
          arr[rear] = elem; //将数据插入到rear所在的位置
          rear = (rear+1 ) % MaxSize;
        } catch (Exception e) {
             e.printStackTrace();
       }
    }
      //出队方法
     public int removeElement(){
          int  varlue = 0; 

          try {
               if(isEmpty()){
                      throw new Exception("队列已空！");
              }
              value = arr[front];
              front = (front+1)%MaxSize;
       } catch (Exception e) {
               e.printStackTrace();
       }
              return value;
      }
}

  

2、不用牺牲存储单元，增加一个成员变量（如 count）记录入队元素的个数，当count=0时队列为空，当count=MaxSize时队列满；Java代码如下：

    public class CircularQueue {
                       private int MaxSize; //队列的容量
                       private int[] arr; //队列的存储结构(用一维数组作为队列的存储结构)
                       private int front;//队头指针
                       private int rear;//队尾指针
                       private int count; //记录入队元素的个数

                public CircularQueue(int MaxSize) { //构造一个队列时需要指定队列的容量
                      this.MaxSize = MaxSize;
                      arr = new int[MaxSize];
                      front = 0;
                      rear = 0;

                      count = 0;
                  }

            //判空
           public boolean isEmpty(){
                return count == 0;
         }

          //判满
         public boolean isFull(){
                return  count == MaxSize;
         }

        //入队
       public void addElement(int elem){
         try {
              if(isFull()){
                  throw new Exception("队列已满!");
            }
          arr[rear] = elem; //将数据插入到rear所在的位置
          rear = (rear+1 ) % MaxSize;

           count++;
        } catch (Exception e) {
             e.printStackTrace();
       }
    }
      //出队方法
     public int removeElement(){
          int  varlue = 0; 

          try {
               if(isEmpty()){
                      throw new Exception("队列已空！");
              }
              value = arr[front];
              front = (front+1)%MaxSize;

              count--;
       } catch (Exception e) {
               e.printStackTrace();
       }
              return value;
      }
}