用Java实现队列和环形队列

1.队列

如果只是想写一个简单的队列的话过程是比较简单的，不过我们首先要明确队列是先进先出，后进后出的原则。
及先进的数先出来，后进的数后出来。
我们可以先将相关的类写出来：

class ArrayQueue{
    private int maxSize;
    private int rear;
    private int front;
    private int[] arr;


    //创建队列构造器
    public ArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        rear = -1;//指向队列尾，指向队列尾的数据（即就是队列最后一个数据）
        front = -1;//指向队列头部，分析出front是指向列队头的前一个位置
    }
    //判断队列是否满
    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++;
        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.println("arr["+i+"]="+arr[i]);
        }
    }
    //显示头数据（注意不是取数据，只是显示头数据）
    public int handQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，无头数据显示");
        }
        return arr[front+1];
    }

}

然后直接在psvm中将测试代码写出并测试，所用的都是些基本的只是，并没有涉及算法问题

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue arrayQueue = 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':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                   break;
                case 'g'://取数据
                    try{
                        int res = arrayQueue.getQueue();
                        System.out.println("取出的数据是"+res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());//若在该过程中有异常输出，则打印相应函数中的异常
                    }
                    break;
                case 'h'://查看队列头的数据
                    try{
                        int res = arrayQueue.handQueue();
                        System.out.println("队列头的数据是"+res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e'://推出程序
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

   存在问题：这样的队列只是“一次性”的队列，即比如说我在一个位置输入一个数字，再取出一个数字，那么这个位置就不再能用了，即使我将数字取出。

如果我们想将该队列的各个位置，输入输出，循环使用，就要将队列堪称一个圈可以无限使用，取入取出。其实与上面的没有什么大的区别只是加了几个算法思想：
1.取模的思想
因为队列是环形相加的，所以里面的值不可能是无限相加的所以就要用到取模的思想例如：

   for (int i=front;i<front+size();i++){
            //因为这个队列是环形的，所以要
            System.out.println("arr["+i%maxSize+"]="+arr[i%maxSize]);
        }

    在遍历队列过程中的i要取模变成i%maxSize

2.留空思想
在上一个例子中说队列的头部索引初始值是-1，即头部索引的前一个，尾部索引初始值也是-1；而在循环队列的代码中，初始值都是0，这样就可以为队列留一个反应空间，比如求出数值有效值的算法

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

下面将具体的整个代码写上，这个是循环队列的代码，队列中的位置可以
循环使用

package Queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        //测试
        System.out.println("测试数组唤醒的模拟队列：");
        //创建一个队列
        CircleArray circleArray = new CircleArray(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':
                    circleArray.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    circleArray.addQueue(value);
                    break;
                case 'g'://取数据
                    try{
                        int res = circleArray.getQueue();
                        System.out.println("取出的数据是"+res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());//若在该过程中有异常输出，则打印相应函数中的异常
                    }
                    break;
                case 'h'://查看队列头的数据
                    try{
                        int res = circleArray.handQueue();
                        System.out.println("队列头的数据是"+res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e'://推出程序
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}
class CircleArray{
    private int maxSize;//表示数组的最大容量
    private int rear;
    private int front;
    private int[] arr;//用于存放数据模拟队列

    public CircleArray(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }
    //判断队列是否满
    public boolean isFull(){
        return (rear+1)%maxSize == front;
    }
    //判断是否为空
    public boolean isEmpty(){
        return rear == front;
    }
    //添加数据到队列
    public void addQueue(int n){
        //判断是否为满
        if (isFull()){
            System.out.println("队列已满，不能添加");
            return;
        }
        arr[rear] = n;//此时rear直接指向最后一个数据
        //将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.println("arr["+i%maxSize+"]="+arr[i%maxSize]);
        }
    }
    //求出当前队列有效数据的个数
    public int size(){
        return (rear+maxSize-front)%maxSize;
    }
    //显示头数据（注意不是取数据，只是显示头数据）
    public int handQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，无头数据显示");
        }
        return arr[front];
    }
}