算法——Java实现队列

顺序队列：

概念：

队列是一种先进先出的线性表，只允许在一端插入，另一端删除。允许插入的一端称为队尾，允许删除的一端称为队头

顺序队列的实现：

 import org.junit.jupiter.api.Test;
 
 /**
  *   顺序队列
  * @author wydream
  *
  */
 
 public class QueueSequence {
 
     private String[] arr;//队列数组
     private int end=0;//队尾标志
 
     //向队列中添加元素
     public void push(String[] arr,String value) {
         if(end<arr.length) {
             arr[end]=value;
             end++;
             return;
         }else {
             System.out.println("队列已经满了");
             return;
         }
 
     }
 
     //取出队列元素
     public String pop(String[] arr) {
         String rs;
         if(arr[0]==null) {
             System.out.println("队列为空,请先向队列中添加元素");
             return null;
         }else {
             rs=arr[0];
             arr[0]=null;
             move(arr);
             return rs;
         }
     }
 
     //队列元素向前移动
     public void move(String[] arr) {
         for(int i=0;i<arr.length-1;i++) {
             if(arr[i+1]!=null) {
                 arr[i]=arr[i+1];
             }else{
                 arr[i]=null;
                 break;
             }
         }
     }
 
     @Test
     public void test() {
         String[] arr=new String[10];
         push(arr,"北京");
         push(arr,"上海");
         push(arr,"广东");
         push(arr,"杭州");
         push(arr,"苏州");
         push(arr,"扬州");
         pop(arr);
         pop(arr);
         pop(arr);
         pop(arr);
     }
 
 }

循环队列：

概念：

• 顺序队列的不足：顺序队列在进行插入操作时，直接在队尾插入就可以，此时时间复杂度为O(1)，但是在出列是在队头，即下标为0的位置，也就意味着队列中所有的元素都得向前移动，此时时间复杂度为0(n)，效率较低。
• 队列出列时不需要所有的元素都移动，引入两个指针即可，一个头指针front指向队头元素，一个尾指针rear指向队尾元素，此时队列出列只需移动指针即可。但是此种情况下会出现一种溢出情况（如下图），此时队列中任然是有空间的可以存放元素的，但是尾指针已经溢出，于是就有了循环队列。
• 
• 
• front指向队头，rear指向队尾的下一个位置；队为空的判断：front==rear；队为满的判断：(rear+1)%MAXSIZE==front

实现循环队列：

 /**
  *   java实现循环队列
  * @author wydream
  *
  */
 
 import org.junit.jupiter.api.Test;
 
 public class QueueArray {
 
     Object[] arr=new Object[10];;//对象数组，队列最多存储a.length-1个对象
     int front=0;//队首下标
     int rear=0;//队尾下标
 
     /**
      *  将一个对象追加到队列尾部
      */
     public boolean enqueue(Object obj) {
         if((rear+1)%arr.length==front) {
             return false;
         }
         arr[rear]=obj;
         rear=(rear+1)%arr.length;
         return true;
 
     }
 
     //出队列
     public Object dequeue() {
         if(rear==front) {
             return null;
         }
         Object obj=arr[front];
         front=(front+1)%arr.length;
         return obj;
     }
 
     @Test
     public void test() {
         QueueArray q=new QueueArray();
         System.out.println(q.enqueue("北京"));
         System.out.println(q.enqueue("上海"));
         System.out.println(q.enqueue("广东"));
         System.out.println(q.enqueue("深圳"));
         for(int i=0;i<4;i++){
             System.out.println(q.dequeue());
         }
     }
 
 }