队列(存储结构数组)--Java实现

 /*队列：其实也是一种操作受限的线性表
  *特点：先进先出
  *队尾指针：负责元素的进队
  *队头指针：负责元素的出队
  *注意：普通队--容易浪费空间，一般队列使用最多的就是循环队列--指针环绕
  *队列的实现方式：数组/链表
  *队列判空判满：
  *1.按照队列中元素的个数
  *2.按照队头和队尾指针的关系
  *存在双端队列：每端都可以插入和删除，其变形可以是操作受限的双端队列
  *队列的应用：其实很多现实世界的规则都是按照排队这种思想
  * */
 public class MyQueue {
     private int items;//队列元素的个数
     private long[] arr;//存储数组
     private int front;//队头指针
     private int rear;//队尾指针
     private int maxSize;//数组的长度

     public MyQueue(int s) {
         maxSize = s;
         arr = new long[maxSize];
         front = 0;
         rear = -1;
         items = 0;
     }

     //进队--先加在取
     public void insert(long key){
         if(rear == maxSize - 1){
             rear = -1;
         }
         arr[++rear] = key;
         items++;
     }

     //出队--先取在加1
     public long remove(){
         long num = arr[front++];
         if(front == maxSize){
             front = 0;
         }
         items--;
         return num;
     }

     //获取队头
     public long getFront(){
         return arr[front];
     }

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

     public boolean isEmpty1(){
         return (rear + 1 == front ||(front + maxSize - 1 == rear));
     }

     //判满
     public boolean isFull(){
         return rear == maxSize;
     }

     public boolean isFull1(){
         return (rear + 2 == front ||(front + maxSize - 2 == rear));
     }

     //获取队列元素个数
     public int size(){
         return items;
     }

     public int size1(){
         if(rear >= front){
             return rear - front + 1;
         }
         else{
             return (maxSize - front) + (rear + 1);
         }
     }

     //显示队列
     public void displayQueue(){
         for(int i = front;i < rear;i++){
             System.out.print(arr[i] + " ");
         }
         System.out.println();
     }

 }