队列（数据结构）

队列

• 队列是一个有序列表，也可以做成环形的队列，可以用数组或者是链表来实现

• 遵循先进先出的原则。即：先存入队列的数据，要先取出。后存入的数据，要后取出。

• 如图所示：
  

思路：

1）设front为队列第一个元素，front初始值为0。

2）设rear为最后一个元素的后一个位置，因为希望空出一个位置当作约定，rear初始值为0。

3）设maxsize为队列的最大值

4）队列满的条件是（rear + 1）%maxsize = front ，可以作为环形队列

5）判断队列空的条件是rear == front

6）队列中的有效元素个数为（rear - front + maxsize）% maxsize，这样做的目的是为了环形

代码实现：

package com.danlianbiao;

import java.util.Scanner;

/**
 * 作者：陈二胖
 * 时间：2021/10/18  19:53
 * 目的：TODO 单链表
 */
public class text {
    public static void main(String[] args){
        ArrayQueqe arrayQueqe = new ArrayQueqe(4);  //定义一个列表，前面为调用函数，后面为名字
        char key = ' '; //用于用户接收,执行何种操作
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while(loop){
            System.out.println("请输入要执行的操作：");
            System.out.println("（s）显示队列");
            System.out.println("（a）添加元素");
            System.out.println("（g）取出元素");
            System.out.println("（h）查看头部元素");
            System.out.println("（e）退出");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    arrayQueqe.showQueqe();
                    break;
                case 'a':
                    System.out.println("输入要添加的元素");
                    int value = scanner.nextInt();
                    arrayQueqe.addQueqe(value);
                    break;
                case 'g':
                    try {
                        int res = arrayQueqe.getQueqe();
                        System.out.println(res);
                        System.out.println("取出成功");
                    }
                    catch (Exception e){
                        System.out.println(e.getMessage());//判断为空时输出isempty里的try语句
                    }
                    break;
                case 'h':
                    try {
                        int res = arrayQueqe.showFront();
                        System.out.println(res);
                    }
                    catch (Exception e){
                        System.out.println(e.getMessage());//判断为空时输出isempty里的try语句
                    }
                    break;
                case 'e':
                    System.out.println("退出成功！");
                    loop = false;
                    break;
            }
        }
    }
    static class ArrayQueqe{
        private int maxsize;  //最大值
        private int front;      //队列头
        private int rear;       //队列尾
        private int[] arr;      //队列

    public ArrayQueqe(int arrmaxSize){
        maxsize = arrmaxSize;
        arr = new int[maxsize];
        front = 0;  //队列头  留一个空，用来缓冲，使得队列可以循环使用
        rear = 0;   //队列尾，指向最后一个元素的后一个位置
    }

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

    public boolean isEmpty(){   //判断队空
        return rear == front;
    }

    public void addQueqe(int n){   //添加数据
        if(isFull()){
            System.out.println("队列满了！");
        }
        else{     //队尾后移一位
            arr[rear] = n;  //先放在空余的格子上，再将rear指向元素后面一个格子
            rear = (rear + 1)%maxsize; //使得能够循环
        }
    }

    public int getQueqe(){   //取数据
        if(isEmpty()){  //先判断是否为空
            throw new RuntimeException("队列为空，不能取数据！");
            // throw 自带return
        }
        int value = arr[front]; //因为front为第一个元素，需要后移，所以要用固定元素来确定他
        front = (front + 1)%maxsize;//使得能够循环
        return value;
    }

    public void showQueqe(){   //显示所有元素
        if (isEmpty()){
            System.out.println("队列为空");
            return;
        }
        else {
            for (int i = front;i<front + (rear + maxsize - front)%maxsize;i++){ //环形队列理解一下！！！
                System.out.printf("arr[%d] = %d\n",i%maxsize,arr[i%maxsize]);
            }
        }
    }

    public int showFront(){   //显示头元素
        if (isEmpty()){
            throw new RuntimeException("队列为空！");
        }
        else {
            return arr[front];
        }
    }
    }
}