使用数组模拟队列

队列的概念：

        队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列的核心理念就是：先进先出！

使用数组模拟队列

package arrqueue;

/*
* 使用数组模拟队列
* */
public class ArrayQueue {
    //队列大小
    private int maxQuqueue;
    //队列头指针
    private int front;
    //队列尾指针
    private int rear;
    //模拟数组
    int[] arr;

    //方法体
    public ArrayQueue(int n){
        maxQuqueue = n;
        front = -1;
        rear = -1;
        arr = new int[n];
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return front == rear;
    }
    //判断队列是否已满
    public boolean isFull(){
        return rear ==maxQuqueue-1;
    }
    //向队列添加元素
    public void addQueue(int num){
        //先判断队列是否已满
        if(isFull()){
            System.out.println("队列已满，无法继续添加数据!");
        }else {
            rear++;
            arr[rear] = num;
        }
    }
    //取出队列中的元素
    public int getQueue(){
        //先判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("队列为空，无法取出数据");
        }else {
            front++;
            return arr[front];
        }
    }

    //查看队列头元素
    public int getHead(){
        //先判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("队列为空，没有头元素");
        }
        return arr[front +1];
    }
    //看看队列中的所有元素
    public void show(){
        //先判断队列是否为空
        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 void menu(){
        System.out.println("1.向队列添加元素   2.从队列取元素\n" +
                           "3.查看队列头元素   4.查看所有元素\n" +
                           "          5.退出系统           ");
    }
}

测试类：

package arrqueue;

import java.util.Scanner;

//测试类
public class Test {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(3);

        Scanner sc = new Scanner(System.in);
        boolean flag = true;
        while (flag){
            System.out.println("---------------------");
            arrayQueue.menu();
            System.out.println("请输入操作对象:");
            String s = sc.next();
            System.out.println("---------------------");
            switch (s){
                case "1":
                    System.out.println("请输入要添加的数字:");
                    int num = sc.nextInt();
                    arrayQueue.addQueue(num);
                    break;
                case "2":
                    try {
                        int queue = arrayQueue.getQueue();
                        System.out.println(queue+"已被取出");
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "3":
                    try {
                        int head = arrayQueue.getHead();
                        System.out.println("队列头元素:"+head);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "4":
                    arrayQueue.show();
                    break;
                case "5":
                    flag = false;
            }
        }
        System.out.println("程序结束...");
    }
}

缺陷：这样模拟的数组只能使用一次，向队列中插入maxQueue个元素再取出之后再想插入元素就会显示队列已满；这时就需要改进，使用数组模拟环形队列，使这个数组可以循环复用。

改进(使用数组模拟环形队列):

1.front指向队列的第一个元素，初始值=0

2.rear指向队列的最后一个元素的后一个位置（预留一个位置），初始值=0

3.队列已满的条件：（rear+1）%maxQueue=front

eg:如果队列大小为4，因为要预留一个位置，所以队列中有三个元素就已满，此时front=0，rear=3；（rear+1）%maxQueue = front = 0;

4.队列为空的条件：front=rear

5.队列中的有效元素个数：（rear-front+maxQueue）%maxQueue

  因为是环形队列，rear有可能会在front的后面，所以上面用了取模操作

package arrcircle_queue;
/*
* 用数组模拟环形队列
* */
public class ArrayCircleQueue {
    //队列大小
    private int maxQuqueue;
    //队列头指针(默认为0)
    private int front;
    //队列尾指针(默认为0)
    private int rear;
    //模拟数组
    int[] arr;

    //方法体
    public ArrayCircleQueue(int n){
        maxQuqueue = n;
        arr = new int[n];
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return rear == front;
    }
    //判断队列是否已满
    public boolean isFull(){
        //预留一个位置
        return (rear +1)%maxQuqueue == front;
    }
    //向队列添加元素
    public void addQueue(int num){
        //先判断队列是否已满
        if(isFull()){
            System.out.println("队列已满，无法继续添加数据!");
        }else {
            arr[rear] = num;
            //tailPointer后移,一直无脑移会导致数组越界，这里运用取模使tailPointer到预留位置后下标再回来
            rear = (rear +1)%maxQuqueue;
        }
    }
    //取出队列中的元素
    public int getQueue(){
        //先判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("队列为空，无法取出数据");
        }else {
            //这里如果直接返回就无法进行headPointer++的操作，所以要定义第三方接收
            int value = arr[front];
            front = (front +1)%maxQuqueue;
            return value;
        }
    }

    //查看队列头元素
    public int getHead(){
        //先判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("队列为空，没有头元素");
        }
        return arr[front];
    }
    //看看队列中的所有元素
    public void show(){
        //先判断队列是否为空
        if(isEmpty()){
            System.out.println("队列为空");
            return;
        }
        //从headPointer开始，输出有效个数个
        for(int i = front; i< front +size(); i++){
            System.out.printf("arr[%d] = %d\n",i%maxQuqueue,arr[i%maxQuqueue]);
        }
    }
    //查看队列中的元素总数
    public int size(){
        return (rear +maxQuqueue- front)%maxQuqueue;
    }
    //菜单
    public void menu(){
        System.out.println("1.向队列添加元素   2.从队列取元素\n" +
                "3.查看队列头元素   4.查看所有元素\n" +
                "          5.退出系统           ");
    }
}

测试类：

package arrcircle_queue;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        ArrayCircleQueue arrayCircleQueue = new ArrayCircleQueue(4);

        Scanner sc = new Scanner(System.in);
        boolean flag = true;
        while (flag){
            System.out.println("---------------------");
            arrayCircleQueue.menu();
            System.out.println("请输入操作对象:");
            String s = sc.next();
            System.out.println("---------------------");
            switch (s){
                case "1":
                    System.out.println("请输入要添加的数字:");
                    int num = sc.nextInt();
                    arrayCircleQueue.addQueue(num);
                    break;
                case "2":
                    try {
                        int queue = arrayCircleQueue.getQueue();
                        System.out.println(queue+"已被取出");
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "3":
                    try {
                        int head = arrayCircleQueue.getHead();
                        System.out.println("队列头元素:"+head);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "4":
                    arrayCircleQueue.show();
                    break;
                case "5":
                    flag = false;
            }
        }
        System.out.println("程序结束...");
    }
}