Java尚硅谷数据结构与算法学习记录(2)-数组模拟队列、环形队列

第一版：

数组模拟队列

package com.lylicoo.queue;

public class ArrayQueue {
    private int maxSize;//队列最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int [] arr;//该数组用于存放数据，模拟队列

    public ArrayQueue(int arrSize){
        maxSize=arrSize;
        arr=new int[maxSize];
        front=-1;//指向队列头部，分析出front是指向队列头的前一个位置
        rear=-1;//指向队列尾，指向当前队列尾的数据（就是队列最后一个数据）
    }
    //判断队列是否满
    public boolean isFull(){
        return rear==maxSize-1;
    }
    //判断队列是否空
    public boolean isEmply(){
        return rear==front;
    }
    //添加数据到队列
    public void addQueue(int n){
        if (isFull()){
            System.out.println("当前队列满，不能添加数据！");
        }else{
            rear++;
            arr[rear]=n;
        }
    }
    //从队列取出元素
    public int getQueue(){
        if (isEmply()){
            //当函数需要返回值时必须有返回值或者抛出异常
//           System.out.println("当前队列空，不能取出数据！");
//           return 0;//万一取出的数据刚好是0呢？-1呢？ 故选择抛出异常的方式
            throw new RuntimeException("当前队列空，不能取出数据！");
        }else{
            front--;
            return arr[front];
        }
    }
    //显示队列的所有数据
    public void showQueue(){
        if(isEmply()){
            System.out.println("当前队列为空！");
        }
        for (int i=0;i<arr.length;i++){
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
    //显示队列头数据，注意不是取出数据
    public int headQueue(){
        if (isEmply()){
            throw new RuntimeException("当前队列为空！");
        }else{
            return arr[front+1];
        }
    }
}

测试类：

package com.lylicoo.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(3);
        Scanner sc = new Scanner(System.in);
        boolean loop=true;
        while(loop){
            System.out.println("s(show):显示队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):取出数据到队列");
            System.out.println("e(exit):退出程序");
            System.out.println("h(head):查看队列头数据");
            String key = sc.nextLine();
           switch(key){
               case "s":
                    queue.showQueue();
                   break;
               case "a":
                   System.out.println("请输入一个数：");
                   String val = sc.nextLine();
                   queue.addQueue(Integer.parseInt(val));
                   break;
               case "g":
                   try {
                       int num = queue.getQueue();
                       System.out.println("取出的数据是："+num);
                   } catch (Exception e) {
                       e.getMessage();
                   }
                   break;
               case "e":
                   loop=false;
                   break;
               case "h":
                   try {
                       int num = queue.headQueue();
                       System.out.println("队列头数据是："+num);
                       break;
                   } catch (Exception e) {
                       e.getMessage();
                   }
               default:
                   break;
           }
        }
        System.out.println("程序退出！");
    }
}

缺点：
目前数组使用一次就不能使用，未实现复用效果
优化：
将这个数组使用算法，改进成一个环形队列 取模%

第二版：

数组模拟环形队列
思路分析：
1、front变量的含义做一个调整：front指向队列的第一个元素，即arr[front]为队列的第一个元素 front=0;
2、rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，即预留出来一个空间（动态的）可以理解为当数组中还有一个空闲单元时就认为队列已经满了。
rear=0;
3、此时队列满的条件是：(rear+1)%maxSize=front;
如maxSzie=3，rear=2时，此时队列中只有两个元素但认为队列已满，因为是环形，所以取模 rear下标从0开始，所以要＋1，画图更好理解！
4、此时队列空的条件是：rear==front;
5、此时队列中的有效数据个数是：(rear+maxSize-front)%maxSize

优化后：

package com.lylicoo.queue;

public class CircleArrayQueue {
    private int maxSize;//队列最大容量
    private int front;//front指向队列的第一个元素，即arr[front]为队列的第一个元素 front=0;
    private int rear;//指向队列的最后一个元素的后一个位置，即预留出来一个空间 rear=0;
    private int[] arr;//该数组用于存放数据，模拟队列

    public CircleArrayQueue(int arrSize) {
        maxSize = arrSize;
        arr = new int[maxSize];
    }

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

    //判断队列是否空
    public boolean isEmply() {
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int n) {
        if (isFull()) {
            System.out.println("当前队列满，不能添加数据！");
        } else {
            arr[rear] = n;//rear指向的本来就是最后一个元素的后一个位置 故直接加入即可
            //rear后移  因为考虑到是环形（前面可能有空闲单元） 故必须取模
            rear=(rear+1)%maxSize;
        }
    }

    //从队列取出元素
    public int getQueue() {
        if (isEmply()) {
            throw new RuntimeException("当前队列空，不能取出数据！");
        } else {
//            return arr[front];
//            front=(front+1)%maxSize;return之后程序就结束了 无法后移front
            /*分析：1、先定义一个变量把arr[front]的值存下来
                    2、将front后移，考虑到环形 取模
                    3、返回之前变量中存放的arr[front]值
                    */
            int val=arr[front];
            front=(front+1)%maxSize;
            return val;

        }
    }

    //显示队列的所有数据
    public void showQueue() {
        if (isEmply()) {
            System.out.println("当前队列为空！");
        }
        for (int i = front; i < front+ sum(); i++) {
            System.out.printf("arr[%d]=%d\t\n",i%maxSize,arr[i%maxSize]);
        }
    }
//统计当前队列中的有效元素
    public int sum() {
        return (rear+maxSize-front)%maxSize;
    }

    //显示队列头数据，注意不是取出数据
    public int headQueue() {
        if (isEmply()) {
            throw new RuntimeException("当前队列为空！");
        } else {
            return arr[front];
        }
    }
}

测试类：

package com.lylicoo.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
       // ArrayQueue queue = new ArrayQueue(3);
        System.out.println("测试数组模拟环形队列");
        CircleArrayQueue queue=new CircleArrayQueue(4);
        Scanner sc = new Scanner(System.in);
        boolean loop=true;
        while(loop){
            System.out.println("s(show):显示队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):取出数据到队列");
            System.out.println("e(exit):退出程序");
            System.out.println("h(head):查看队列头数据");
            String key = sc.nextLine();
           switch(key){
               case "s":
                    queue.showQueue();
                   break;
               case "a":
                   System.out.println("请输入一个数：");
                   String val = sc.nextLine();
                   queue.addQueue(Integer.parseInt(val));
                   break;
               case "g":
                   try {
                       int num = queue.getQueue();
                       System.out.println("取出的数据是："+num);
                   } catch (Exception e) {
                       e.getMessage();
                   }
                   break;
               case "e":
                   loop=false;
                   break;
               case "h":
                   try {
                       int num = queue.headQueue();
                       System.out.println("队列头数据是："+num);
                       break;
                   } catch (Exception e) {
                       e.getMessage();
                   }
               default:
                   break;
           }
        }
        System.out.println("程序退出！");
    }
}