队列和环形队列的实现

1.数组模拟队列

存在问题：数组使用一次就不能使用了，无法复用

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建队列
        ArrayQueue queue = new ArrayQueue(3);
        //接受用户输入
        int key = 0;
        Scanner scan = new Scanner(System.in);
        boolean flag = true;
        while (flag){
            System.out.println("1:显示队列");
            System.out.println("2:添加数据到队列");
            System.out.println("3:从队列取出数据");
            System.out.println("4:查看队列的头数据(第一个数据)");
            System.out.println("5:退出");
            //接受用户输入的数字
            key = scan.nextInt();
            switch (key) {
                case 1:
                    queue.showAllQueue();
                    break;
                case 2:
                    System.out.println("请输入数据");
                    int value = scan.nextInt();
                    queue.addQueue(value);
                    break;
                case 3:
                    try {
                        int getNum = queue.getQueue();
                        System.out.println("取出的数据为" + getNum);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 4:
                    try {
                        int headNum = queue.headerQueue();
                        System.out.println("取出的头数据为" + headNum);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 5:
                    System.out.println("程序退出");
                    flag = false;
                    scan.close();
                    break;
                default:
                    break;
            }
        }

    }
}

//使用数组模拟队列——编写一个ArrayQueue
class ArrayQueue{
    //数组的最大容量
    private int maxSize;
    //队列头
    private int front;
    //队列尾
    private int rear;
    //模拟队列，存放数据
    private int[] arr;


    //创建队列的构造器 传入数组的容量
    public ArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        //指向队列的头部,是队列头的前一个位置
        front = -1;
        //指向队列的尾部,是队列的最后一个位置
        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("队列为空,无法取出数据");
            //Unreachable statement   此句无法输出
//            System.out.println("队列是空的~~");
        }
        //front向后移一位
        front++;
        return arr[front];
    }

    //显示队列的全部数据
    public void showAllQueue(){
        //判断队列是否为空
        if(isEmpty()){
            System.out.println("队列是空的,无法输出数据");
            return;
        }
        //循环遍历数组
        for (int i = 0 ;i<arr.length;i++){
            System.out.println("arr[" + i +  "] = " + arr[i]);
        }
    }

    //显示队列的第一个数据
    public int headerQueue(){
        //判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("队列是空的~~");
        }
        return arr[front++];
    }


}

2. 数组模拟环形队列

说明：环形队列实现了数组的复用

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        System.out.println("测试环形队列");
        //创建环形队列 空出一个 有效数据为3
        CircleArray queue = new CircleArray(4);
        //接受用户输入
        int key = 0;
        Scanner scan = new Scanner(System.in);
        boolean flag = true;
        while (flag){
            System.out.println("1:显示队列");
            System.out.println("2:添加数据到队列");
            System.out.println("3:从队列取出数据");
            System.out.println("4:查看队列的头数据(第一个数据)");
            System.out.println("5:退出");
            //接受用户输入的数字
            key = scan.nextInt();
            switch (key) {
                case 1:
                    queue.showAllQueue();
                    break;
                case 2:
                    System.out.println("请输入数据");
                    int value = scan.nextInt();
                    queue.addQueue(value);
                    break;
                case 3:
                    try {
                        int getNum = queue.getQueue();
                        System.out.println("取出的数据为" + getNum);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 4:
                    try {
                        int headNum = queue.headerQueue();
                        System.out.println("取出的头数据为" + headNum);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 5:
                    System.out.println("程序退出~~");
                    flag = false;
                    scan.close();
                    break;
                default:
                    break;
            }
        }

    }
}

class CircleArray{
    //数组的最大容量
    private int maxSize;
    //队列头 指向队列的第一个元素 即初始值front=0
    private int front=0;
    //队列尾  指向队列的倒数第二个元素   空出一个位置来判断满没满  初始值rear=0
    private int rear;
    //模拟队列，存放数据
    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 + 1) % maxSize;

    }

    //从队列中取出数据
    public int getQueue(){
        //判断队列是否为空
        if(isEmpty()){
            //抛出一个异常
            throw new RuntimeException("队列为空,无法取出数据");
        }
        // 此时front指向的是队列的第一个元素
        // 因此将front对应的值保存到一个临时变量  然后后移   因为是循环队列  考虑取模
        int value = arr[front];
        front = (front+1)%maxSize ;
        return value;

    }

    //显示队列的全部数据
    public void showAllQueue(){
        //判断队列是否为空
        if(isEmpty()) {
            System.out.println("队列是空的,无法输出数据");
            return;
        }
        for (int i = front ;i<front+size();i++){
            System.out.println("arr[" + i % maxSize +  "] = " + arr[i % maxSize]);
        }

    }

    //求出当前队列有效数据的个数
    public int size(){
        //假设最大容量maxsize = 6  添加数据时rear后移 因此指向位置是没有数据 而front是取出数据后移 因此front指向位置有数据
        //情况一 rear=2 ,front=0  则有效数据为(2-0+6)%6 = 2
        //情况二  rear = 0 ,front=4  此情况是数据有出有进导致  有效数据为(0-4+6)%6 = 4
        //画图理解
        return (rear - front + maxSize) %maxSize;
    }

    //显示队列的第一个数据
    public int headerQueue(){
        //判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("队列是空的~~");
        }
        return arr[front];
    }


}