环形队列-Java

• 队列的概念：

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

• 特点

先进先出

• front变量含义:front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素，front的初始值为0。
• rear变量含义:rear指向最后一个元素的后一个位置，因为希望空出一个空间做为约定，rear的初始值为0。
• 初始化时：front = rear = 0；
  入队时，队首进1：front = （front + 1) % maxSize；
  入队时，队尾进1：rear = （rear + 1）% maxSize；
  队列数据个数：（front + maxSize- rear) % maxSize；

CircleArrayQueue类

import java.util.Scanner;

public class CircleArrayQueue {
    public static void main(String[] args){
        System.out.println("测试数组模拟环形队列");
        circleQueue q = new circleQueue(4);//设置为4，其队列的最大长度为3
        Scanner in = new Scanner(System.in);
        boolean t = true;
        while(t){
            System.out.println("s(Show):显示队列");
            System.out.println("e(Exit):退出程序");
            System.out.println("a(Add):添加数据到队列");
            System.out.println("g(Get):从队列中取出数据");
            System.out.println("p(Peek):查看队列头的数据");
            String str = in.next();
            char key = str.charAt(0);//接收一个字符
            switch(key){//
                case 's':
                    q.show();
                    break;
                case 'a':
                    System.out.println("请添加一个数:");
                    int value = in.nextInt();
                    q.addQueue(value);
                    break;
                case 'g':
                    try{
                        int num = q.getQueue();
                        System.out.printf("取出的数据为:%dn",num);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'p':
                    try{
                        int num = q.peekQueue();
                        System.out.printf("给队列的头元素是:%dn",num);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    in.close();
                    t = false;
                    break;
            }
        }
        System.out.println("程序结束");
    }
}

circleQueue类

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

    //创建队列的构造器
    public circleQueue(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 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("队列为空，不能取数据");
            //throw后面不能添加语句
        }
        //front是指向队列的第一个元素
        //1.先把front对应的值保存到一个变量中
        //2.将front后移
        //3.最后将变量返回
        int value = arr[front];
        front = (front+1)%maxSize;
        return value;
    }
    //计算队列有效个数
    public int Size(){
        return (rear-front+maxSize)%maxSize;
    }
    //显示队列的所有数据
    public void show(){//遍历
        //判断队列是否为空
        if(isEmpty()){
            System.out.println("队列为空，无法显示数据");
            return;
        }
        for (int i = front; i < front+Size(); i++) {
            System.out.printf("arr[%d]= %dn",i%maxSize,arr[i%maxSize]);
        }
    }
    //显示队列的头数据
    public int peekQueue(){
        //判断队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }
        return arr[front];
    }
}