数据结构——队列

1. 队列

1.1 队列介绍

- 队列是一个有序列表，可以使用数组或链表来实现
- 遵循先入先出的原则。即，先存入队列的数据，要先取出。后存入的数据后取出
- 示意图
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/02ea826ad5564a18bcaf4ce7d64384bd.png)

1.2 队列的使用场景 — 银行排队的案例

1.3 数组模拟队列的思路

• 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列最大的容量。

• 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据的输出而改变， rear会根据数据的输入而改变，如下图所示：
  

• 当我们将数据存入队列时称为 “addQueue”， addQueue处理需要两个步骤：思路分析
  1）将尾针指针往后移动： rear + 1, 当front = = rear 【空】
  2）若尾针指针rear 小于队列的最大下标 maxSize - 1，则将数据存入rear 所指的数组元素中，否则无法存入数据。 rear == maxSize - 1 【队列满】

• 代码实现

  package com.sss.quene;
  
  import java.util.Scanner;
  
   public class ArrayQueneDemo {
       public static void main(String[] args) {
           // 测试一把
           // 创建一个队列
           ArrayQueue queue = new ArrayQueue(3);
           char key = ' '; // 接收用户输入
           Scanner scanner = new Scanner(System.in);
           boolean loop = true;
           while (loop) {
               // 输出一个菜单
               System.out.println("s(show): 显示队列");
               System.out.println("e(exit): 退出程序");
               System.out.println("a(add): 添加数据到队列");
               System.out.println("g(get): 从队列取出数据");
               System.out.println("h(head): 查看队列头的数据");
               key = scanner.next().charAt(0); // 接收一个字符
               switch (key) {
                   case 's':
                       queue.showQueue();
                       break;
                   case 'a':
                       System.out.println("输入一个数");
                       int value = scanner.nextInt();
                       queue.addQueue(value);
                       break;
                   case 'g': // 取出数据
                       try {
                           int res = queue.getQueue();
                           System.out.printf("取出的数据是%d\n", res);
                       } catch (Exception e) {
                           System.out.println(e.getMessage());
                       }
                       break;
                   case 'h':
                       try {
                           int head = queue.headQueue();
                           System.out.printf("队列头的数据是%d\n", head);
                       } catch (Exception e) {
                           System.out.println(e.getMessage());
                       }
                       break;
                   case 'e': // 退出
                       scanner.close();
                       loop = false;
                       break;
                   default:
                       break;
               }
           }
           System.out.println("程序退出");
       }
   
   }
   
   class  ArrayQueue {
   
       private int maxSize;//表示数组的最大容量
       private int front;//队列头
       private int rear;//队列尾
       private int[] arr;//该数据用于存放数据，模拟队列
   
   
       // 创建队列的构造器
       public ArrayQueue(int maxSize) {
           this.maxSize = maxSize;
           arr = new int[maxSize];
           front = -1;// 指向队列头部，分析出front是指向队列头的前一个位置
           rear = -1;// 指向队列尾，指向队列尾的数据（即队列最后一个数据）
       }
   
       // 判断队列是否满
       public boolean isFull() {
           return rear == maxSize - 1;
       }
   
       // 判断队列是否为空
       public boolean isEmpty() {
           return rear == front;
       }
   
       // 添加数据到队列
       public void addQueue(int n) {
           // 判断数据是否满
           if(isFull()) {
               System.out.println("队列满，不能添加数据");
               return;
           }
           rear++; // 让rear后移
           arr[rear] = n;
       }
   
       public int getQueue() {
           // 判断队列是否空
           if(isEmpty()) {
               throw new RuntimeException("队列空，不能取出数据");
           }
           front++; // front后移
           return arr[front];
       }
   
       // 显示队列的所有数据
       public void showQueue() {
           // 遍历
           if(isEmpty()) {
               System.out.println("队列空，没有数据");
               return;
           }
           for (int i = 0; i < arr.length; i++) {
               System.out.printf("arr[%d]=%d\n", i, arr[i]);
           }
       }
   
       // 显示队列的头数据，注意不是取出数据
       public int headQueue() {
           // 判断
           if(isEmpty()) {
               throw new RuntimeException("队列空，没有数据");
           }
           return arr[front + 1];
       }
   
   }
  
  

• 问题分析及优化
  1）目前数组使用一次就不能使用，没有达到复用的效果
  2）将这个数组使用算法，改进成一个环形的队列 取模： %

1.4 数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组，因此将数组看成是 一个环形的。（通过取模的方式来实现即可）

• 分析说明
  • 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在判断队列满的时候需要注意 (rear + 1) % maxSize == front 满
  • rear == front [空]
  • 分析示意图：
    
    思路如下：
    1、front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front] 就是队列的第一个元素 front的初始值为 0
    2、rear变量的含义做一个调整：rear指向队列最后一个元素的后一个位置。因为希望空出一个空间作为约定，rear的初始值为 0
    3、当队列满时，条件是（rear + 1）%maxSize = front [满]
    4、队列为空的条件， rear == front
    5、当我们这样分析，队列中有效的数据的个数为 (rear + maxSize - front)% maxSize // rear = 1 front = 0
    6、我们就可以在原来的队列上

代码实现

public class CircleArrayQueueDemo {

   public static void main(String[] args) {
       // 测试一把
       System.out.println("测试数组模拟环形队列的案例··");

       // 创建一个队列
       CircleArrayQueue queue = new CircleArrayQueue(4);// 说明设置4， 其队列的有效数据最大是3
       char key = ' '; // 接收用户输入
       Scanner scanner = new Scanner(System.in);
       boolean loop = true;
       while (loop) {
           // 输出一个菜单
           System.out.println("s(show): 显示队列");
           System.out.println("e(exit): 退出程序");
           System.out.println("a(add): 添加数据到队列");
           System.out.println("g(get): 从队列取出数据");
           System.out.println("h(head): 查看队列头的数据");
           key = scanner.next().charAt(0); // 接收一个字符
           switch (key) {
               case 's':
                   queue.showQueue();
                   break;
               case 'a':
                   System.out.println("输入一个数");
                   int value = scanner.nextInt();
                   queue.addQueue(value);
                   break;
               case 'g': // 取出数据
                   try {
                       int res = queue.getQueue();
                       System.out.printf("取出的数据是%d\n", res);
                   } catch (Exception e) {
                       System.out.println(e.getMessage());
                   }
                   break;
               case 'h':
                   try {
                       int head = queue.headQueue();
                       System.out.printf("队列头的数据是%d\n", head);
                   } catch (Exception e) {
                       System.out.println(e.getMessage());
                   }
                   break;
               case 'e': // 退出
                   scanner.close();
                   loop = false;
                   break;
               default:
                   break;
           }
       }
       System.out.println("程序退出");
   }
}

class CircleArrayQueue {

   private int maxSize;//表示数组的最大容量
   private int front;// front就指向队列的第一个元素，也就是说arr[front] 就是队列的第一个元素 front的初始值为 0
   private int rear;// rear指向队列最后一个元素的后一个位置。因为希望空出一个空间作为约定，rear的初始值为 0
   private int[] arr;//该数据用于存放数据，模拟队列

   public CircleArrayQueue(int maxSize) {
       this.maxSize = maxSize;
       arr = new int[maxSize];
   }

   // 判断队列是否满
   public boolean isFull() {
       return rear == maxSize - 1;
   }

   // 判断队列是否为空
   public boolean isEmpty() {
       return (rear + 1)%maxSize == front;
   }

   // 添加数据到队列
   public void addQueue(int n) {
       // 判断数据是否满
       if(isFull()) {
           System.out.println("队列满，不能添加数据");
           return;
       }
       arr[rear] = n;
       // 将rear后移，这里必须考虑取模
       rear = (rear + 1) % maxSize;
   }

   public int getQueue() {
       // 判断队列是否空
       if(isEmpty()) {
           throw new RuntimeException("队列空，不能取出数据");
       }
       // 这里需要分析出front是指向队列的第一个元素
       // 1、先把front对应的值保留到一个额临时变量
       // 2、将front后移，考虑取模
       // 3、将临时保存的变量返回
       int value = arr[front];
       front = (front + 1) % maxSize;
       return value;
   }

   // 显示队列的所有数据
   public void showQueue() {
       // 遍历
       if(isEmpty()) {
           System.out.println("队列空，没有数据");
           return;
       }
       // 思路：从front开始遍历，遍历多少个元素
       for (int i = front; i < front + size(); i++) {
           System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
       }
   }

   // 求出当前队列有效数据的个数
   public int size() {
       return (rear + maxSize - front) % maxSize;
   }

   // 显示队列的头数据，注意不是取出数据
   public int headQueue() {
       // 判断
       if(isEmpty()) {
           throw new RuntimeException("队列空，没有数据");
       }
       return arr[front];
   }
}